2007-09-24 09:29:12 +04:00
|
|
|
#!/bin/sh
|
|
|
|
|
|
|
|
test_description='git remote porcelain-ish'
|
|
|
|
|
|
|
|
. ./test-lib.sh
|
|
|
|
|
|
|
|
setup_repository () {
|
|
|
|
mkdir "$1" && (
|
|
|
|
cd "$1" &&
|
|
|
|
git init &&
|
|
|
|
>file &&
|
|
|
|
git add file &&
|
2008-03-04 14:23:53 +03:00
|
|
|
test_tick &&
|
2007-09-24 09:29:12 +04:00
|
|
|
git commit -m "Initial" &&
|
|
|
|
git checkout -b side &&
|
|
|
|
>elif &&
|
|
|
|
git add elif &&
|
2008-03-04 14:23:53 +03:00
|
|
|
test_tick &&
|
2007-09-24 09:29:12 +04:00
|
|
|
git commit -m "Second" &&
|
|
|
|
git checkout master
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
tokens_match () {
|
|
|
|
echo "$1" | tr ' ' '\012' | sort | sed -e '/^$/d' >expect &&
|
|
|
|
echo "$2" | tr ' ' '\012' | sort | sed -e '/^$/d' >actual &&
|
2008-03-13 00:36:36 +03:00
|
|
|
test_cmp expect actual
|
2007-09-24 09:29:12 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
check_remote_track () {
|
2009-02-25 11:32:27 +03:00
|
|
|
actual=$(git remote show "$1" | sed -ne 's|^ \(.*\) tracked$|\1|p')
|
2007-09-24 09:29:12 +04: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 11:58:08 +04:00
|
|
|
cd two &&
|
|
|
|
git branch another
|
2007-09-24 09:29:12 +04:00
|
|
|
) &&
|
|
|
|
git clone one test
|
|
|
|
'
|
|
|
|
|
2012-08-27 09:36:54 +04:00
|
|
|
test_expect_success C_LOCALE_OUTPUT 'remote information for the origin' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
tokens_match origin "$(git remote)" &&
|
|
|
|
check_remote_track origin master side &&
|
|
|
|
check_tracking_branch origin HEAD master side
|
|
|
|
)
|
2007-09-24 09:29:12 +04:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'add another remote' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
git remote add -f second ../two &&
|
|
|
|
tokens_match "origin second" "$(git remote)" &&
|
|
|
|
check_tracking_branch second master side another &&
|
|
|
|
git for-each-ref "--format=%(refname)" refs/remotes |
|
|
|
|
sed -e "/^refs\/remotes\/origin\//d" \
|
|
|
|
-e "/^refs\/remotes\/second\//d" >actual &&
|
|
|
|
>expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
)
|
2007-09-24 09:29:12 +04:00
|
|
|
'
|
|
|
|
|
2013-07-03 13:12:34 +04:00
|
|
|
test_expect_success C_LOCALE_OUTPUT 'check remote-tracking' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
check_remote_track origin master side &&
|
|
|
|
check_remote_track second master side another
|
|
|
|
)
|
2012-08-27 09:36:54 +04:00
|
|
|
'
|
|
|
|
|
2008-04-22 15:11:13 +04:00
|
|
|
test_expect_success 'remote forces tracking branches' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
case `git config remote.second.fetch` in
|
|
|
|
+*) true ;;
|
|
|
|
*) false ;;
|
|
|
|
esac
|
|
|
|
)
|
2008-04-22 15:11:13 +04:00
|
|
|
'
|
|
|
|
|
2007-09-24 09:29:12 +04:00
|
|
|
test_expect_success 'remove remote' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
git symbolic-ref refs/remotes/second/HEAD refs/remotes/second/master &&
|
|
|
|
git remote rm second
|
|
|
|
)
|
2007-09-24 09:29:12 +04:00
|
|
|
'
|
|
|
|
|
2012-08-27 09:36:54 +04:00
|
|
|
test_expect_success C_LOCALE_OUTPUT 'remove remote' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
tokens_match origin "$(git remote)" &&
|
|
|
|
check_remote_track origin master side &&
|
|
|
|
git for-each-ref "--format=%(refname)" refs/remotes |
|
|
|
|
sed -e "/^refs\/remotes\/origin\//d" >actual &&
|
|
|
|
>expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
)
|
2007-09-24 09:29:12 +04:00
|
|
|
'
|
|
|
|
|
2010-11-02 18:31:25 +03:00
|
|
|
test_expect_success 'remove remote protects local branches' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
cat >expect1 <<-\EOF &&
|
|
|
|
Note: A branch outside the refs/remotes/ hierarchy was not removed;
|
|
|
|
to delete it, use:
|
|
|
|
git branch -d master
|
|
|
|
EOF
|
|
|
|
cat >expect2 <<-\EOF &&
|
|
|
|
Note: Some branches outside the refs/remotes/ hierarchy were not removed;
|
|
|
|
to delete them, use:
|
|
|
|
git branch -d foobranch
|
|
|
|
git branch -d master
|
|
|
|
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 &&
|
|
|
|
test_i18ncmp expect1 actual1 &&
|
|
|
|
test_i18ncmp expect2 actual2
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >test/expect <<EOF
|
2008-02-29 04:45:24 +03:00
|
|
|
* remote origin
|
2009-06-13 20:29:10 +04:00
|
|
|
Fetch URL: $(pwd)/one
|
|
|
|
Push URL: $(pwd)/one
|
2009-02-25 11:32:24 +03:00
|
|
|
HEAD branch: master
|
2009-02-25 11:32:27 +03:00
|
|
|
Remote branches:
|
|
|
|
master new (next fetch will store in remotes/origin)
|
|
|
|
side tracked
|
|
|
|
Local branches configured for 'git pull':
|
2009-02-25 11:32:28 +03:00
|
|
|
ahead merges with remote master
|
2009-02-25 11:32:27 +03:00
|
|
|
master merges with remote master
|
|
|
|
octopus merges with remote topic-a
|
|
|
|
and with remote topic-b
|
|
|
|
and with remote topic-c
|
|
|
|
rebase rebases onto remote master
|
2009-02-25 11:32:28 +03:00
|
|
|
Local refs configured for 'git push':
|
|
|
|
master pushes to master (local out of date)
|
|
|
|
master pushes to upstream (create)
|
2009-02-25 11:32:24 +03:00
|
|
|
* remote two
|
2009-06-13 20:29:10 +04:00
|
|
|
Fetch URL: ../two
|
|
|
|
Push URL: ../three
|
2009-02-25 11:32:24 +03:00
|
|
|
HEAD branch (remote HEAD is ambiguous, may be one of the following):
|
|
|
|
another
|
|
|
|
master
|
2009-02-25 11:32:28 +03:00
|
|
|
Local refs configured for 'git push':
|
2009-10-24 12:31:32 +04:00
|
|
|
ahead forces to master (fast-forwardable)
|
2009-02-25 11:32:28 +03:00
|
|
|
master pushes to another (up to date)
|
2008-02-29 04:45:24 +03:00
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'show' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
git config --add remote.origin.fetch refs/heads/master:refs/heads/upstream &&
|
|
|
|
git fetch &&
|
|
|
|
git checkout -b ahead origin/master &&
|
|
|
|
echo 1 >>file &&
|
|
|
|
test_tick &&
|
|
|
|
git commit -m update file &&
|
|
|
|
git checkout master &&
|
|
|
|
git branch --track octopus origin/master &&
|
|
|
|
git branch --track rebase origin/master &&
|
|
|
|
git branch -d -r origin/master &&
|
|
|
|
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 : &&
|
|
|
|
git config --add remote.origin.push refs/heads/master:refs/heads/upstream &&
|
|
|
|
git config --add remote.origin.push +refs/tags/lastbackup &&
|
|
|
|
git config --add remote.two.push +refs/heads/ahead:refs/heads/master &&
|
|
|
|
git config --add remote.two.push refs/heads/master:refs/heads/another &&
|
|
|
|
git remote show origin two >output &&
|
|
|
|
git branch -d rebase octopus &&
|
|
|
|
test_i18ncmp expect output
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >test/expect <<EOF
|
2008-06-10 18:51:08 +04:00
|
|
|
* remote origin
|
2009-06-13 20:29:10 +04:00
|
|
|
Fetch URL: $(pwd)/one
|
|
|
|
Push URL: $(pwd)/one
|
2009-02-25 11:32:24 +03:00
|
|
|
HEAD branch: (not queried)
|
2009-02-25 11:32:27 +03:00
|
|
|
Remote branches: (status not queried)
|
2008-10-22 11:39:47 +04:00
|
|
|
master
|
|
|
|
side
|
2009-02-25 11:32:28 +03:00
|
|
|
Local branches configured for 'git pull':
|
|
|
|
ahead merges with remote master
|
2009-02-25 11:32:27 +03:00
|
|
|
master merges with remote master
|
2009-02-25 11:32:28 +03:00
|
|
|
Local refs configured for 'git push' (status not queried):
|
|
|
|
(matching) pushes to (matching)
|
|
|
|
refs/heads/master pushes to refs/heads/upstream
|
|
|
|
refs/tags/lastbackup forces to refs/tags/lastbackup
|
2008-06-10 18:51:08 +04:00
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'show -n' '
|
2013-06-22 11:58:08 +04:00
|
|
|
mv one one.unreachable &&
|
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
git remote show -n origin >output &&
|
|
|
|
mv ../one.unreachable ../one &&
|
|
|
|
test_i18ncmp expect output
|
|
|
|
)
|
2008-06-10 18:51:08 +04:00
|
|
|
'
|
|
|
|
|
2008-02-29 04:45:24 +03:00
|
|
|
test_expect_success 'prune' '
|
2013-06-22 11:58:08 +04: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 04:45:24 +03:00
|
|
|
'
|
|
|
|
|
2009-02-25 11:32:25 +03:00
|
|
|
test_expect_success 'set-head --delete' '
|
2013-06-22 11:58:08 +04: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 11:32:25 +03:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'set-head --auto' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
git remote set-head --auto origin &&
|
|
|
|
echo refs/remotes/origin/master >expect &&
|
|
|
|
git symbolic-ref refs/remotes/origin/HEAD >output &&
|
|
|
|
test_cmp expect output
|
2009-02-25 11:32:25 +03:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2013-06-22 11:58:08 +04:00
|
|
|
cat >test/expect <<\EOF
|
2009-02-25 11:32:25 +03:00
|
|
|
error: Multiple remote HEAD branches. Please choose one explicitly with:
|
|
|
|
git remote set-head two another
|
|
|
|
git remote set-head two master
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'set-head --auto fails w/multiple HEADs' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
test_must_fail git remote set-head --auto two >output 2>&1 &&
|
|
|
|
test_i18ncmp expect output
|
|
|
|
)
|
2009-02-25 11:32:25 +03:00
|
|
|
'
|
|
|
|
|
2013-06-22 11:58:08 +04:00
|
|
|
cat >test/expect <<\EOF
|
2009-02-25 11:32:25 +03:00
|
|
|
refs/remotes/origin/side2
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'set-head explicit' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd test &&
|
|
|
|
git remote set-head origin side2 &&
|
|
|
|
git symbolic-ref refs/remotes/origin/HEAD >output &&
|
|
|
|
git remote set-head origin master &&
|
|
|
|
test_cmp expect output
|
|
|
|
)
|
2009-02-25 11:32:25 +03:00
|
|
|
'
|
|
|
|
|
2013-06-22 11:58:08 +04:00
|
|
|
cat >test/expect <<EOF
|
2008-06-10 18:51:35 +04:00
|
|
|
Pruning origin
|
2008-09-01 23:07:33 +04:00
|
|
|
URL: $(pwd)/one
|
2008-06-10 18:51:35 +04:00
|
|
|
* [would prune] origin/side2
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'prune --dry-run' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
git branch -m side2 side) &&
|
|
|
|
(
|
|
|
|
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 &&
|
|
|
|
(
|
|
|
|
cd ../one &&
|
|
|
|
git branch -m side side2) &&
|
|
|
|
test_i18ncmp expect output
|
|
|
|
)
|
2008-06-10 18:51:35 +04:00
|
|
|
'
|
|
|
|
|
2008-02-29 04:46:07 +03:00
|
|
|
test_expect_success 'add --mirror && prune' '
|
2013-06-22 11:58:08 +04: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 04:46:07 +03: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 23:53:19 +04:00
|
|
|
test_expect_success 'add --mirror=fetch' '
|
|
|
|
mkdir mirror-fetch &&
|
|
|
|
git init mirror-fetch/parent &&
|
2013-06-22 11:58:08 +04: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 23:53:19 +04:00
|
|
|
git init --bare mirror-fetch/child &&
|
2013-06-22 11:58:08 +04: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 23:53:19 +04:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'fetch mirrors act as mirrors during fetch' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd mirror-fetch/parent &&
|
|
|
|
git branch new &&
|
|
|
|
git branch -m master 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 23:53:19 +04:00
|
|
|
) &&
|
2013-06-22 11:58:08 +04: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 23:53:19 +04:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'fetch mirrors can prune' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd mirror-fetch/child &&
|
|
|
|
git remote prune parent &&
|
|
|
|
test_must_fail git rev-parse --verify refs/heads/master
|
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 23:53:19 +04:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'fetch mirrors do not act as mirrors during push' '
|
2013-06-22 11:58:08 +04: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 23:53:19 +04:00
|
|
|
) &&
|
2013-06-22 11:58:08 +04: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 23:53:19 +04:00
|
|
|
) &&
|
2013-06-22 11:58:08 +04: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 23:53:19 +04:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2011-05-26 19:11:00 +04:00
|
|
|
test_expect_success 'add fetch mirror with specific branches' '
|
|
|
|
git init --bare mirror-fetch/track &&
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd mirror-fetch/track &&
|
|
|
|
git remote add --mirror=fetch -t heads/new parent ../parent
|
2011-05-26 19:11:00 +04:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'fetch mirror respects specific branches' '
|
2013-06-22 11:58:08 +04: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 19:11:00 +04: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 23:53:19 +04:00
|
|
|
test_expect_success 'add --mirror=push' '
|
|
|
|
mkdir mirror-push &&
|
|
|
|
git init --bare mirror-push/public &&
|
|
|
|
git init mirror-push/private &&
|
2013-06-22 11:58:08 +04: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 23:53:19 +04:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'push mirrors act as mirrors during push' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd mirror-push/private &&
|
|
|
|
git branch new &&
|
|
|
|
git branch -m master renamed &&
|
|
|
|
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 23:53:19 +04:00
|
|
|
) &&
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd mirror-push/private &&
|
|
|
|
git rev-parse --verify refs/heads/new &&
|
|
|
|
git rev-parse --verify refs/heads/renamed &&
|
|
|
|
test_must_fail git rev-parse --verify refs/heads/master
|
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 23:53:19 +04:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'push mirrors do not act as mirrors during fetch' '
|
2013-06-22 11:58:08 +04: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 23:53:19 +04:00
|
|
|
) &&
|
2013-06-22 11:58:08 +04: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 23:53:19 +04:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2011-05-26 19:11:00 +04:00
|
|
|
test_expect_success 'push mirrors do not allow you to specify refs' '
|
|
|
|
git init mirror-push/track &&
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd mirror-push/track &&
|
|
|
|
test_must_fail git remote add --mirror=push -t new public ../public
|
2011-05-26 19:11:00 +04:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2008-06-01 07:58:05 +04:00
|
|
|
test_expect_success 'add alt && prune' '
|
2013-06-22 11:58:08 +04: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 07:58:05 +04:00
|
|
|
'
|
|
|
|
|
2010-04-20 03:31:31 +04:00
|
|
|
cat >test/expect <<\EOF
|
|
|
|
some-tag
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'add with reachable tags (default)' '
|
2013-06-22 11:58:08 +04: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-20 03:31:31 +04: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 11:58:08 +04: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-20 03:31:31 +04:00
|
|
|
test_cmp test/expect test/output
|
|
|
|
'
|
|
|
|
|
|
|
|
cat >test/expect <<\EOF
|
|
|
|
--no-tags
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'add --no-tags' '
|
2013-06-22 11:58:08 +04:00
|
|
|
rm -rf add-tags &&
|
|
|
|
(
|
|
|
|
mkdir add-no-tags &&
|
|
|
|
cd add-no-tags &&
|
|
|
|
git init &&
|
|
|
|
git remote add -f --no-tags origin ../one &&
|
|
|
|
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-20 03:31:31 +04:00
|
|
|
test_cmp test/expect test/output
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'reject --no-no-tags' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd add-no-tags &&
|
|
|
|
test_must_fail git remote add -f --no-no-tags neworigin ../one
|
|
|
|
)
|
2010-04-20 03:31:31 +04:00
|
|
|
'
|
|
|
|
|
2013-06-22 11:58:08 +04:00
|
|
|
cat >one/expect <<\EOF
|
2008-03-04 14:23:53 +03:00
|
|
|
apis/master
|
|
|
|
apis/side
|
|
|
|
drosophila/another
|
|
|
|
drosophila/master
|
|
|
|
drosophila/side
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'update' '
|
2013-06-22 11:58:08 +04: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 14:23:53 +03:00
|
|
|
'
|
|
|
|
|
2013-06-22 11:58:08 +04:00
|
|
|
cat >one/expect <<\EOF
|
2008-03-04 14:23:53 +03:00
|
|
|
drosophila/another
|
|
|
|
drosophila/master
|
|
|
|
drosophila/side
|
|
|
|
manduca/master
|
|
|
|
manduca/side
|
|
|
|
megaloprepus/master
|
|
|
|
megaloprepus/side
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'update with arguments' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
for b in $(git branch -r)
|
|
|
|
do
|
2008-03-04 14:23:53 +03:00
|
|
|
git branch -r -d $b || break
|
2013-06-22 11:58:08 +04: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 14:23:53 +03:00
|
|
|
'
|
|
|
|
|
2009-11-09 23:11:59 +03:00
|
|
|
test_expect_success 'update --prune' '
|
2013-06-22 11:58:08 +04: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 23:11:59 +03:00
|
|
|
'
|
|
|
|
|
2013-06-22 11:58:08 +04:00
|
|
|
cat >one/expect <<-\EOF
|
2008-03-04 14:23:53 +03:00
|
|
|
apis/master
|
|
|
|
apis/side
|
|
|
|
manduca/master
|
|
|
|
manduca/side
|
|
|
|
megaloprepus/master
|
|
|
|
megaloprepus/side
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'update default' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
for b in $(git branch -r)
|
|
|
|
do
|
2008-03-04 14:23:53 +03:00
|
|
|
git branch -r -d $b || break
|
2013-06-22 11:58:08 +04:00
|
|
|
done &&
|
|
|
|
git config remote.drosophila.skipDefaultUpdate true &&
|
|
|
|
git remote update default &&
|
|
|
|
git branch -r >output &&
|
|
|
|
test_cmp expect output
|
|
|
|
)
|
2008-03-04 14:23:53 +03:00
|
|
|
'
|
|
|
|
|
2013-06-22 11:58:08 +04:00
|
|
|
cat >one/expect <<\EOF
|
2008-03-04 14:23:53 +03:00
|
|
|
drosophila/another
|
|
|
|
drosophila/master
|
|
|
|
drosophila/side
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_expect_success 'update default (overridden, with funny whitespace)' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
for b in $(git branch -r)
|
|
|
|
do
|
2008-03-04 14:23:53 +03:00
|
|
|
git branch -r -d $b || break
|
2013-06-22 11:58:08 +04: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 14:23:53 +03:00
|
|
|
'
|
|
|
|
|
2009-12-31 12:43:17 +03:00
|
|
|
test_expect_success 'update (with remotes.default defined)' '
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
for b in $(git branch -r)
|
|
|
|
do
|
2009-12-31 12:43:17 +03:00
|
|
|
git branch -r -d $b || break
|
2013-06-22 11:58:08 +04:00
|
|
|
done &&
|
|
|
|
git config remotes.default "drosophila" &&
|
|
|
|
git remote update &&
|
|
|
|
git branch -r >output &&
|
|
|
|
test_cmp expect output
|
|
|
|
)
|
2009-12-31 12:43:17 +03:00
|
|
|
'
|
|
|
|
|
2008-03-19 03:27:42 +03:00
|
|
|
test_expect_success '"remote show" does not show symbolic refs' '
|
|
|
|
git clone one three &&
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd three &&
|
|
|
|
git remote show origin >output &&
|
|
|
|
! grep "^ *HEAD$" < output &&
|
|
|
|
! grep -i stale < output
|
|
|
|
)
|
2008-03-19 03:27:42 +03:00
|
|
|
'
|
|
|
|
|
2008-04-13 13:56:54 +04:00
|
|
|
test_expect_success 'reject adding remote with an invalid name' '
|
2008-07-12 19:47:52 +04:00
|
|
|
test_must_fail git remote add some:url desired-name
|
2008-04-13 13:56:54 +04:00
|
|
|
'
|
|
|
|
|
2008-11-03 21:26:18 +03: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' '
|
|
|
|
git clone one four &&
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd four &&
|
|
|
|
git remote rename origin upstream &&
|
|
|
|
rmdir .git/refs/remotes/origin &&
|
|
|
|
test "$(git symbolic-ref refs/remotes/upstream/HEAD)" = "refs/remotes/upstream/master" &&
|
|
|
|
test "$(git rev-parse upstream/master)" = "$(git rev-parse master)" &&
|
|
|
|
test "$(git config remote.upstream.fetch)" = "+refs/heads/*:refs/remotes/upstream/*" &&
|
|
|
|
test "$(git config branch.master.remote)" = "upstream"
|
|
|
|
)
|
2008-11-03 21:26:18 +03:00
|
|
|
'
|
2008-11-10 23:43:01 +03:00
|
|
|
|
2011-09-02 04:50:33 +04:00
|
|
|
test_expect_success 'rename does not update a non-default fetch refspec' '
|
|
|
|
git clone one four.one &&
|
2013-06-22 11:58:08 +04: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/*" &&
|
|
|
|
git rev-parse -q origin/master
|
|
|
|
)
|
2011-09-02 04:50:33 +04:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'rename a remote with name part of fetch spec' '
|
|
|
|
git clone one four.two &&
|
2013-06-22 11:58:08 +04: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 04:50:33 +04:00
|
|
|
'
|
|
|
|
|
2011-09-02 04:50:34 +04:00
|
|
|
test_expect_success 'rename a remote with name prefix of other remote' '
|
|
|
|
git clone one four.three &&
|
2013-06-22 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd four.three &&
|
|
|
|
git remote add o git://example.com/repo.git &&
|
|
|
|
git remote rename o upstream &&
|
|
|
|
test "$(git rev-parse origin/master)" = "$(git rev-parse master)"
|
|
|
|
)
|
2011-09-02 04:50:34 +04:00
|
|
|
'
|
|
|
|
|
2013-06-22 11:58:08 +04:00
|
|
|
cat >remotes_origin <<EOF
|
2008-11-10 23:43:01 +03:00
|
|
|
URL: $(pwd)/one
|
|
|
|
Push: refs/heads/master:refs/heads/upstream
|
2013-06-22 11:58:18 +04:00
|
|
|
Push: refs/heads/next:refs/heads/upstream2
|
2008-11-10 23:43:01 +03:00
|
|
|
Pull: refs/heads/master:refs/heads/origin
|
2013-06-22 11:58:18 +04:00
|
|
|
Pull: refs/heads/next:refs/heads/origin2
|
2008-11-10 23:43:01 +03: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 11:58:08 +04: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 11:58:10 +04:00
|
|
|
test_path_is_missing .git/remotes/origin &&
|
2013-06-22 11:58:08 +04:00
|
|
|
test "$(git config remote.origin.url)" = "$origin_url" &&
|
2013-06-22 11:58:18 +04:00
|
|
|
cat >push_expected <<-\EOF &&
|
|
|
|
refs/heads/master:refs/heads/upstream
|
|
|
|
refs/heads/next:refs/heads/upstream2
|
|
|
|
EOF
|
|
|
|
cat >fetch_expected <<-\EOF &&
|
|
|
|
refs/heads/master:refs/heads/origin
|
|
|
|
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 11:58:08 +04:00
|
|
|
)
|
2008-11-10 23:43:01 +03: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 11:58:08 +04:00
|
|
|
(
|
|
|
|
cd six &&
|
|
|
|
git remote rm origin &&
|
|
|
|
echo "$origin_url" >.git/branches/origin &&
|
|
|
|
git remote rename origin origin &&
|
2013-06-22 11:58:10 +04:00
|
|
|
test_path_is_missing .git/branches/origin &&
|
2013-06-22 11:58:08 +04:00
|
|
|
test "$(git config remote.origin.url)" = "$origin_url" &&
|
2013-06-22 11:58:09 +04:00
|
|
|
test "$(git config remote.origin.fetch)" = "refs/heads/master:refs/heads/origin" &&
|
|
|
|
test "$(git config remote.origin.push)" = "HEAD:refs/heads/master"
|
2013-06-22 11:58:08 +04:00
|
|
|
)
|
2008-11-10 23:43:01 +03:00
|
|
|
'
|
|
|
|
|
2013-06-22 11:58:13 +04:00
|
|
|
test_expect_success 'migrate a remote from named file in $GIT_DIR/branches (2)' '
|
2009-02-09 10:27:10 +03:00
|
|
|
git clone one seven &&
|
2013-06-22 11:58:13 +04: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" &&
|
|
|
|
test "$(git config remote.origin.fetch)" = "refs/heads/foom:refs/heads/origin"
|
|
|
|
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 10:27:10 +03:00
|
|
|
(
|
|
|
|
cd one &&
|
|
|
|
git checkout side2 &&
|
|
|
|
git branch -D master
|
|
|
|
) &&
|
|
|
|
(
|
2013-06-22 11:58:13 +04:00
|
|
|
cd eight &&
|
2009-02-09 10:27:10 +03:00
|
|
|
git remote prune origin
|
2010-03-16 08:12:55 +03:00
|
|
|
) >err 2>&1 &&
|
2012-08-27 09:36:54 +04:00
|
|
|
test_i18ngrep "has become dangling" err &&
|
2009-02-09 10:27:10 +03:00
|
|
|
|
2010-03-16 08:12:55 +03:00
|
|
|
: And the dangling symref will not cause other annoying errors &&
|
2009-02-09 10:27:10 +03:00
|
|
|
(
|
2013-06-22 11:58:13 +04:00
|
|
|
cd eight &&
|
2009-02-09 10:27:10 +03:00
|
|
|
git branch -a
|
|
|
|
) 2>err &&
|
2010-03-16 08:12:55 +03:00
|
|
|
! grep "points nowhere" err &&
|
2009-02-09 10:52:01 +03:00
|
|
|
(
|
2013-06-22 11:58:13 +04:00
|
|
|
cd eight &&
|
2009-02-09 10:52:01 +03:00
|
|
|
test_must_fail git branch nomore origin
|
|
|
|
) 2>err &&
|
|
|
|
grep "dangling symref" err
|
2009-02-09 10:27:10 +03:00
|
|
|
'
|
|
|
|
|
2009-05-28 00:13:43 +04: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 22:38:50 +04: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
|
|
|
|
+refs/heads/master:refs/remotes/scratch/master
|
|
|
|
+refs/heads/next:refs/remotes/scratch/next
|
|
|
|
EOF
|
|
|
|
sort <<-\EOF >expect.add-two &&
|
|
|
|
+refs/heads/maint:refs/remotes/scratch/maint
|
|
|
|
+refs/heads/master:refs/remotes/scratch/master
|
|
|
|
+refs/heads/next:refs/remotes/scratch/next
|
|
|
|
+refs/heads/pu:refs/remotes/scratch/pu
|
|
|
|
+refs/heads/t/topic:refs/remotes/scratch/t/topic
|
|
|
|
EOF
|
|
|
|
sort <<-\EOF >expect.setup-ffonly &&
|
|
|
|
refs/heads/master:refs/remotes/scratch/master
|
|
|
|
+refs/heads/next:refs/remotes/scratch/next
|
|
|
|
EOF
|
|
|
|
sort <<-\EOF >expect.respect-ffonly &&
|
|
|
|
refs/heads/master:refs/remotes/scratch/master
|
|
|
|
+refs/heads/next:refs/remotes/scratch/next
|
|
|
|
+refs/heads/pu:refs/remotes/scratch/pu
|
|
|
|
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 &&
|
|
|
|
|
|
|
|
git remote set-branches scratch maint master next &&
|
|
|
|
git config --get-all remote.scratch.fetch >config-result &&
|
|
|
|
sort <config-result >../actual.replace &&
|
|
|
|
|
|
|
|
git remote set-branches --add scratch pu t/topic &&
|
|
|
|
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 \
|
|
|
|
refs/heads/master:refs/remotes/scratch/master &&
|
|
|
|
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 &&
|
|
|
|
|
|
|
|
git remote set-branches --add scratch pu &&
|
|
|
|
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 &&
|
|
|
|
echo "+refs/heads/master:refs/heads/master" >expect.replace &&
|
|
|
|
git clone --mirror .git/ setbranches-mirror &&
|
|
|
|
(
|
|
|
|
cd setbranches-mirror &&
|
|
|
|
git remote rename origin scratch &&
|
|
|
|
git config --get-all remote.scratch.fetch >../actual.initial &&
|
|
|
|
|
|
|
|
git remote set-branches scratch heads/master &&
|
|
|
|
git config --get-all remote.scratch.fetch >../actual.replace
|
|
|
|
) &&
|
|
|
|
test_cmp expect.initial actual.initial &&
|
|
|
|
test_cmp expect.replace actual.replace
|
|
|
|
'
|
|
|
|
|
2010-01-18 20:18:02 +03: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
|
|
|
|
'
|
|
|
|
|
|
|
|
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 10:52:01 +03:00
|
|
|
|
2010-01-18 20:18:02 +03: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
|
|
|
|
'
|
|
|
|
|
|
|
|
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
|
|
|
|
'
|
|
|
|
|
|
|
|
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
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'remote set-url --delete .*' '
|
2010-03-20 03:10:20 +03:00
|
|
|
test_must_fail git remote set-url --delete someremote .\* &&
|
2010-01-18 20:18:02 +03: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 17:54:35 +04: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 17:54:37 +04:00
|
|
|
test_expect_success "extra args: $*" "
|
2013-04-24 17:54:35 +04:00
|
|
|
test_must_fail git remote $* bogus_extra_arg 2>actual &&
|
|
|
|
grep '^usage:' actual
|
|
|
|
"
|
|
|
|
}
|
|
|
|
|
2013-04-24 17:54:36 +04:00
|
|
|
test_extra_arg add nick url
|
2013-04-24 17:54:35 +04:00
|
|
|
test_extra_arg rename origin newname
|
|
|
|
test_extra_arg remove origin
|
|
|
|
test_extra_arg set-head origin master
|
|
|
|
# set-branches takes any number of args
|
|
|
|
test_extra_arg set-url origin newurl oldurl
|
2013-04-24 17:54:37 +04:00
|
|
|
# show takes any number of args
|
|
|
|
# prune takes any number of args
|
2013-04-24 17:54:35 +04:00
|
|
|
# update takes any number of args
|
|
|
|
|
2010-01-18 20:18:02 +03:00
|
|
|
test_done
|