maurice/snix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

merge(3p/git): Merge git subtree at v2.29.2

Browse source 
This also bumps the stable nixpkgs to 20.09 as of 2020-11-21, because
there is some breakage in the git build related to the netrc
credentials helper which someone has taken care of in nixpkgs.

The stable channel is not used for anything other than git, so this
should be fine.

Change-Id: I3575a19dab09e1e9556cf8231d717de9890484fb
This commit is contained in:
Vincent Ambo 2020-11-21 19:20:35 +01:00
parent 082c006c04
commit f4609b896f
1485 changed files with 241535 additions and 109418 deletions
Download patch file Download diff file Expand all files Collapse all files

56
third_party/git/t/t5411/common-functions.sh vendored Normal file
View file

@ -0,0 +1,56 @@
# Create commits in <repo> and assign each commit's oid to shell variables
# given in the arguments (A, B, and C). E.g.:
#
# create_commits_in <repo> A B C
#
# NOTE: Never calling this function from a subshell since variable
# assignments will disappear when subshell exits.
create_commits_in () {
repo="$1" &&
if ! parent=$(git -C "$repo" rev-parse HEAD^{} --)
then
parent=
fi &&
T=$(git -C "$repo" write-tree) &&
shift &&
while test $# -gt 0
do
name=$1 &&
test_tick &&
if test -z "$parent"
then
oid=$(echo $name | git -C "$repo" commit-tree $T)
else
oid=$(echo $name | git -C "$repo" commit-tree -p $parent $T)
fi &&
eval $name=$oid &&
parent=$oid &&
shift ||
return 1
done &&
git -C "$repo" update-ref refs/heads/master $oid
}
# Format the output of git-push, git-show-ref and other commands to make a
# user-friendly and stable text. We can easily prepare the expect text
# without having to worry about future changes of the commit ID and spaces
# of the output. Single quotes are replaced with double quotes, because
# it is boring to prepare unquoted single quotes in expect text. We also
# remove some locale error messages, which break test if we turn on
# `GIT_TEST_GETTEXT_POISON=true` in order to test unintentional translations
# on plumbing commands.
make_user_friendly_and_stable_output () {
sed \
-e "s/ *\$//" \
-e "s/ */ /g" \
-e "s/'/\"/g" \
-e "s/ / /g" \
-e "s/$A/<COMMIT-A>/g" \
-e "s/$B/<COMMIT-B>/g" \
-e "s/$TAG/<TAG-v123>/g" \
-e "s/$ZERO_OID/<ZERO-OID>/g" \
-e "s/$(echo $A | cut -c1-7)[0-9a-f]*/<OID-A>/g" \
-e "s/$(echo $B | cut -c1-7)[0-9a-f]*/<OID-B>/g" \
-e "s#To $URL_PREFIX/upstream.git#To <URL/of/upstream.git>#" \
-e "/^error: / d"
}

94
third_party/git/t/t5411/once-0010-report-status-v1.sh vendored Normal file
View file

@ -0,0 +1,94 @@
test_expect_success "setup receive.procReceiveRefs" '
git -C "$upstream" config --add receive.procReceiveRefs refs/for
'
test_expect_success "setup proc-receive hook" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic1" \
-r "option fall-through" \
-r "ok refs/for/master/topic2" \
-r "option refname refs/for/changes/23/123/1" \
-r "option new-oid $A" \
-r "ok refs/for/master/topic2" \
-r "option refname refs/for/changes/24/124/2" \
-r "option old-oid $B" \
-r "option new-oid $A" \
-r "option forced-update" \
-r "ng refs/for/next/topic target branch not exist"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : (B) refs/for/master/topic1(A) foo(A) refs/for/next/topic(A) refs/for/master/topic2(A)
test_expect_success "proc-receive: report status v1" '
{
if test -z "$GIT_DEFAULT_HASH" || test "$GIT_DEFAULT_HASH" = "sha1"
then
printf "%s %s refs/heads/master\0report-status\n" \
$A $B | packetize
else
printf "%s %s refs/heads/master\0report-status object-format=$GIT_DEFAULT_HASH\n" \
$A $B | packetize
fi &&
printf "%s %s refs/for/master/topic1\n" \
$ZERO_OID $A | packetize &&
printf "%s %s refs/heads/foo\n" \
$ZERO_OID $A | packetize &&
printf "%s %s refs/for/next/topic\n" \
$ZERO_OID $A | packetize &&
printf "%s %s refs/for/master/topic2\n" \
$ZERO_OID $A | packetize &&
printf 0000 &&
printf "" | git -C "$upstream" pack-objects --stdout
} | git receive-pack "$upstream" --stateless-rpc \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
# pre-receive hook
pre-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic1
pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/foo
pre-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic
pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic2
# proc-receive hook
proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic1
proc-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic
proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic2
proc-receive> ok refs/for/master/topic1
proc-receive> option fall-through
proc-receive> ok refs/for/master/topic2
proc-receive> option refname refs/for/changes/23/123/1
proc-receive> option new-oid <COMMIT-A>
proc-receive> ok refs/for/master/topic2
proc-receive> option refname refs/for/changes/24/124/2
proc-receive> option old-oid <COMMIT-B>
proc-receive> option new-oid <COMMIT-A>
proc-receive> option forced-update
proc-receive> ng refs/for/next/topic target branch not exist
000eunpack ok
0019ok refs/heads/master
001eok refs/for/master/topic1
0016ok refs/heads/foo
0033ng refs/for/next/topic target branch not exist
001eok refs/for/master/topic2
0000# post-receive hook
post-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
post-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic1
post-receive< <ZERO-OID> <COMMIT-A> refs/heads/foo
post-receive< <ZERO-OID> <COMMIT-A> refs/for/changes/23/123/1
post-receive< <COMMIT-B> <COMMIT-A> refs/for/changes/24/124/2
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/for/master/topic1
<COMMIT-A> refs/heads/foo
<COMMIT-B> refs/heads/master
EOF
test_cmp expect actual
'

143
third_party/git/t/t5411/test-0000-standard-git-push.sh vendored Normal file
View file

@ -0,0 +1,143 @@
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git-push : master(B) next(A)
test_expect_success "git-push ($PROTOCOL)" '
git -C workbench push origin \
$B:refs/heads/master \
HEAD:refs/heads/next \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
remote: # post-receive hook
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
To <URL/of/upstream.git>
<OID-A>..<OID-B> <COMMIT-B> -> master
* [new branch] HEAD -> next
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-B> refs/heads/master
<COMMIT-A> refs/heads/next
EOF
test_cmp expect actual
'
# Refs of upstream : master(B) next(A)
# Refs of workbench: master(A) tags/v123
# git-push --atomic: master(A) next(B)
test_expect_success "git-push --atomic ($PROTOCOL)" '
test_must_fail git -C workbench push --atomic origin \
master \
$B:refs/heads/next \
>out 2>&1 &&
make_user_friendly_and_stable_output <out |
sed -n \
-e "/^To / { s/ */ /g; p; }" \
-e "/^ ! / { s/ */ /g; p; }" \
>actual &&
cat >expect <<-EOF &&
To <URL/of/upstream.git>
! [rejected] master -> master (non-fast-forward)
! [rejected] <COMMIT-B> -> next (atomic push failed)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-B> refs/heads/master
<COMMIT-A> refs/heads/next
EOF
test_cmp expect actual
'
# Refs of upstream : master(B) next(A)
# Refs of workbench: master(A) tags/v123
# git-push : master(A) next(B)
test_expect_success "non-fast-forward git-push ($PROTOCOL)" '
test_must_fail git \
-C workbench \
-c advice.pushUpdateRejected=false \
push origin \
master \
$B:refs/heads/next \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <COMMIT-A> <COMMIT-B> refs/heads/next
remote: # post-receive hook
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/heads/next
To <URL/of/upstream.git>
<OID-A>..<OID-B> <COMMIT-B> -> next
! [rejected] master -> master (non-fast-forward)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-B> refs/heads/master
<COMMIT-B> refs/heads/next
EOF
test_cmp expect actual
'
# Refs of upstream : master(B) next(B)
# Refs of workbench: master(A) tags/v123
# git-push -f : master(A) NULL tags/v123 refs/review/master/topic(A) a/b/c(A)
test_expect_success "git-push -f ($PROTOCOL)" '
git -C workbench push -f origin \
refs/tags/v123 \
:refs/heads/next \
master \
master:refs/review/master/topic \
HEAD:refs/heads/a/b/c \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <COMMIT-B> <COMMIT-A> refs/heads/master
remote: pre-receive< <COMMIT-B> <ZERO-OID> refs/heads/next
remote: pre-receive< <ZERO-OID> <TAG-v123> refs/tags/v123
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/review/master/topic
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/a/b/c
remote: # post-receive hook
remote: post-receive< <COMMIT-B> <COMMIT-A> refs/heads/master
remote: post-receive< <COMMIT-B> <ZERO-OID> refs/heads/next
remote: post-receive< <ZERO-OID> <TAG-v123> refs/tags/v123
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/review/master/topic
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/heads/a/b/c
To <URL/of/upstream.git>
+ <OID-B>...<OID-A> master -> master (forced update)
- [deleted] next
* [new tag] v123 -> v123
* [new reference] master -> refs/review/master/topic
* [new branch] HEAD -> a/b/c
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/a/b/c
<COMMIT-A> refs/heads/master
<COMMIT-A> refs/review/master/topic
<TAG-v123> refs/tags/v123
EOF
test_cmp expect actual
'
# Refs of upstream : master(A) tags/v123 refs/review/master/topic(A) a/b/c(A)
# Refs of workbench: master(A) tags/v123
test_expect_success "cleanup ($PROTOCOL)" '
(
cd "$upstream" &&
git update-ref -d refs/review/master/topic &&
git update-ref -d refs/tags/v123 &&
git update-ref -d refs/heads/a/b/c
)
'

147
third_party/git/t/t5411/test-0001-standard-git-push--porcelain.sh vendored Normal file
View file

@ -0,0 +1,147 @@
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git-push : master(B) next(A)
test_expect_success "git-push ($PROTOCOL/porcelain)" '
git -C workbench push --porcelain origin \
$B:refs/heads/master \
HEAD:refs/heads/next \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
remote: # post-receive hook
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
To <URL/of/upstream.git>
<COMMIT-B>:refs/heads/master <OID-A>..<OID-B>
* HEAD:refs/heads/next [new branch]
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-B> refs/heads/master
<COMMIT-A> refs/heads/next
EOF
test_cmp expect actual
'
# Refs of upstream : master(B) next(A)
# Refs of workbench: master(A) tags/v123
# git-push --atomic: master(A) next(B)
test_expect_success "git-push --atomic ($PROTOCOL/porcelain)" '
test_must_fail git -C workbench push --atomic --porcelain origin \
master \
$B:refs/heads/next \
>out 2>&1 &&
make_user_friendly_and_stable_output <out |
sed -n \
-e "s/^# GETTEXT POISON #//" \
-e "/^To / { s/ */ /g; p; }" \
-e "/^! / { s/ */ /g; p; }" \
>actual &&
cat >expect <<-EOF &&
To <URL/of/upstream.git>
! refs/heads/master:refs/heads/master [rejected] (non-fast-forward)
! <COMMIT-B>:refs/heads/next [rejected] (atomic push failed)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-B> refs/heads/master
<COMMIT-A> refs/heads/next
EOF
test_cmp expect actual
'
# Refs of upstream : master(B) next(A)
# Refs of workbench: master(A) tags/v123
# git-push : master(A) next(B)
test_expect_success "non-fast-forward git-push ($PROTOCOL/porcelain)" '
test_must_fail git \
-C workbench \
-c advice.pushUpdateRejected=false \
push --porcelain origin \
master \
$B:refs/heads/next \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <COMMIT-A> <COMMIT-B> refs/heads/next
remote: # post-receive hook
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/heads/next
To <URL/of/upstream.git>
<COMMIT-B>:refs/heads/next <OID-A>..<OID-B>
! refs/heads/master:refs/heads/master [rejected] (non-fast-forward)
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-B> refs/heads/master
<COMMIT-B> refs/heads/next
EOF
test_cmp expect actual
'
# Refs of upstream : master(B) next(B)
# Refs of workbench: master(A) tags/v123
# git-push -f : master(A) NULL tags/v123 refs/review/master/topic(A) a/b/c(A)
test_expect_success "git-push -f ($PROTOCOL/porcelain)" '
git -C workbench push --porcelain -f origin \
refs/tags/v123 \
:refs/heads/next \
master \
master:refs/review/master/topic \
HEAD:refs/heads/a/b/c \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <COMMIT-B> <COMMIT-A> refs/heads/master
remote: pre-receive< <COMMIT-B> <ZERO-OID> refs/heads/next
remote: pre-receive< <ZERO-OID> <TAG-v123> refs/tags/v123
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/review/master/topic
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/a/b/c
remote: # post-receive hook
remote: post-receive< <COMMIT-B> <COMMIT-A> refs/heads/master
remote: post-receive< <COMMIT-B> <ZERO-OID> refs/heads/next
remote: post-receive< <ZERO-OID> <TAG-v123> refs/tags/v123
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/review/master/topic
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/heads/a/b/c
To <URL/of/upstream.git>
+ refs/heads/master:refs/heads/master <OID-B>...<OID-A> (forced update)
- :refs/heads/next [deleted]
* refs/tags/v123:refs/tags/v123 [new tag]
* refs/heads/master:refs/review/master/topic [new reference]
* HEAD:refs/heads/a/b/c [new branch]
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/a/b/c
<COMMIT-A> refs/heads/master
<COMMIT-A> refs/review/master/topic
<TAG-v123> refs/tags/v123
EOF
test_cmp expect actual
'
# Refs of upstream : master(A) tags/v123 refs/review/master/topic(A) a/b/c(A)
# Refs of workbench: master(A) tags/v123
test_expect_success "cleanup ($PROTOCOL/porcelain)" '
(
cd "$upstream" &&
git update-ref -d refs/review/master/topic &&
git update-ref -d refs/tags/v123 &&
git update-ref -d refs/heads/a/b/c
)
'

33
third_party/git/t/t5411/test-0002-pre-receive-declined.sh vendored Normal file
View file

@ -0,0 +1,33 @@
test_expect_success "setup pre-receive hook ($PROTOCOL)" '
mv "$upstream/hooks/pre-receive" "$upstream/hooks/pre-receive.ok" &&
write_script "$upstream/hooks/pre-receive" <<-EOF
exit 1
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git-push : master(B) next(A)
test_expect_success "git-push is declined ($PROTOCOL)" '
test_must_fail git -C workbench push origin \
$B:refs/heads/master \
HEAD:refs/heads/next \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
To <URL/of/upstream.git>
! [remote rejected] <COMMIT-B> -> master (pre-receive hook declined)
! [remote rejected] HEAD -> next (pre-receive hook declined)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "cleanup ($PROTOCOL)" '
mv "$upstream/hooks/pre-receive.ok" "$upstream/hooks/pre-receive"
'

34
third_party/git/t/t5411/test-0003-pre-receive-declined--porcelain.sh vendored Normal file
View file

@ -0,0 +1,34 @@
test_expect_success "setup pre-receive hook ($PROTOCOL/porcelain)" '
mv "$upstream/hooks/pre-receive" "$upstream/hooks/pre-receive.ok" &&
write_script "$upstream/hooks/pre-receive" <<-EOF
exit 1
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git-push : master(B) next(A)
test_expect_success "git-push is declined ($PROTOCOL/porcelain)" '
test_must_fail git -C workbench push --porcelain origin \
$B:refs/heads/master \
HEAD:refs/heads/next \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
To <URL/of/upstream.git>
! <COMMIT-B>:refs/heads/master [remote rejected] (pre-receive hook declined)
! HEAD:refs/heads/next [remote rejected] (pre-receive hook declined)
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "cleanup ($PROTOCOL/porcelain)" '
mv "$upstream/hooks/pre-receive.ok" "$upstream/hooks/pre-receive"
'

7
third_party/git/t/t5411/test-0010-proc-receive-settings.sh vendored Normal file
View file

@ -0,0 +1,7 @@
test_expect_success "add two receive.procReceiveRefs settings" '
(
cd "$upstream" &&
git config --add receive.procReceiveRefs refs/for &&
git config --add receive.procReceiveRefs refs/review/
)
'

64
third_party/git/t/t5411/test-0011-no-hook-error.sh vendored Normal file
View file

@ -0,0 +1,64 @@
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : next(A) refs/for/master/topic(A)
test_expect_success "proc-receive: no hook, fail to push special ref ($PROTOCOL)" '
test_must_fail git -C workbench push origin \
HEAD:next \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: error: cannot find hook "proc-receive"
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
To <URL/of/upstream.git>
* [new branch] HEAD -> next
! [remote rejected] HEAD -> refs/for/master/topic (fail to run proc-receive hook)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
<COMMIT-A> refs/heads/next
EOF
test_cmp expect actual
'
# Refs of upstream : master(A) next(A)
# Refs of workbench: master(A) tags/v123
test_expect_success "cleanup ($PROTOCOL)" '
git -C "$upstream" update-ref -d refs/heads/next
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push --atomic: (B) next(A) refs/for/master/topic(A)
test_expect_success "proc-receive: no hook, all failed for atomic push ($PROTOCOL)" '
test_must_fail git -C workbench push --atomic origin \
$B:master \
HEAD:next \
HEAD:refs/for/master/topic >out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: error: cannot find hook "proc-receive"
To <URL/of/upstream.git>
! [remote rejected] <COMMIT-B> -> master (fail to run proc-receive hook)
! [remote rejected] HEAD -> next (fail to run proc-receive hook)
! [remote rejected] HEAD -> refs/for/master/topic (fail to run proc-receive hook)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'

66
third_party/git/t/t5411/test-0012-no-hook-error--porcelain.sh vendored Normal file
View file

@ -0,0 +1,66 @@
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : next(A) refs/for/master/topic(A)
test_expect_success "proc-receive: no hook, fail to push special ref ($PROTOCOL/porcelain)" '
test_must_fail git -C workbench push --porcelain origin \
HEAD:next \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: error: cannot find hook "proc-receive"
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
To <URL/of/upstream.git>
* HEAD:refs/heads/next [new branch]
! HEAD:refs/for/master/topic [remote rejected] (fail to run proc-receive hook)
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
<COMMIT-A> refs/heads/next
EOF
test_cmp expect actual
'
# Refs of upstream : master(A) next(A)
# Refs of workbench: master(A) tags/v123
test_expect_success "cleanup ($PROTOCOL/porcelain)" '
git -C "$upstream" update-ref -d refs/heads/next
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push --atomic: (B) next(A) refs/for/master/topic(A)
test_expect_success "proc-receive: no hook, all failed for atomic push ($PROTOCOL/porcelain)" '
test_must_fail git -C workbench push --porcelain --atomic origin \
$B:master \
HEAD:next \
HEAD:refs/for/master/topic >out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: error: cannot find hook "proc-receive"
To <URL/of/upstream.git>
! <COMMIT-B>:refs/heads/master [remote rejected] (fail to run proc-receive hook)
! HEAD:refs/heads/next [remote rejected] (fail to run proc-receive hook)
! HEAD:refs/for/master/topic [remote rejected] (fail to run proc-receive hook)
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'

217
third_party/git/t/t5411/test-0013-bad-protocol.sh vendored Normal file
View file

@ -0,0 +1,217 @@
test_expect_success "setup proc-receive hook (unknown version, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v --version 2
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic(A)
test_expect_success "proc-receive: bad protocol (unknown version, $PROTOCOL)" '
test_must_fail git -C workbench push origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
# Check status report for git-push
sed -n \
-e "/^To / { p; n; p; }" \
<actual >actual-report &&
cat >expect <<-EOF &&
To <URL/of/upstream.git>
! [remote rejected] HEAD -> refs/for/master/topic (fail to run proc-receive hook)
EOF
test_cmp expect actual-report &&
# Check error message from "receive-pack", but ignore unstable fatal error
# message ("remote: fatal: the remote end hung up unexpectedly") which
# is different from the remote HTTP server with different locale settings.
grep "^remote: error:" <actual >actual-error &&
cat >expect <<-EOF &&
remote: error: proc-receive version "2" is not supported
EOF
test_cmp expect actual-error &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (hook --die-version, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v --die-version
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic(A)
test_expect_success "proc-receive: bad protocol (hook --die-version, $PROTOCOL)" '
test_must_fail git -C workbench push origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: fatal: bad protocol version: 1
remote: error: proc-receive version "0" is not supported
To <URL/of/upstream.git>
! [remote rejected] HEAD -> refs/for/master/topic (fail to run proc-receive hook)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (hook --die-readline, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v --die-readline
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic(A)
test_expect_success "proc-receive: bad protocol (hook --die-readline, $PROTOCOL)" '
test_must_fail git -C workbench push origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
grep "remote: fatal: protocol error: expected \"old new ref\", got \"<ZERO-OID> <COMMIT-A> refs/for/master/topic\"" actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (no report, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : next(A) refs/for/master/topic(A)
test_expect_success "proc-receive: bad protocol (no report, $PROTOCOL)" '
test_must_fail git -C workbench push origin \
HEAD:refs/heads/next \
HEAD:refs/for/master/topic >out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
To <URL/of/upstream.git>
* [new branch] HEAD -> next
! [remote rejected] HEAD -> refs/for/master/topic (proc-receive failed to report status)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
<COMMIT-A> refs/heads/next
EOF
test_cmp expect actual
'
# Refs of upstream : master(A) next(A)
# Refs of workbench: master(A) tags/v123
test_expect_success "cleanup ($PROTOCOL)" '
git -C "$upstream" update-ref -d refs/heads/next
'
test_expect_success "setup proc-receive hook (no ref, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic
test_expect_success "proc-receive: bad protocol (no ref, $PROTOCOL)" '
test_must_fail git -C workbench push origin \
HEAD:refs/for/master/topic\
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok
remote: error: proc-receive reported incomplete status line: "ok"
To <URL/of/upstream.git>
! [remote rejected] HEAD -> refs/for/master/topic (proc-receive failed to report status)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (unknown status, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "xx refs/for/master/topic"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic
test_expect_success "proc-receive: bad protocol (unknown status, $PROTOCOL)" '
test_must_fail git -C workbench push origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> xx refs/for/master/topic
remote: error: proc-receive reported bad status "xx" on ref "refs/for/master/topic"
To <URL/of/upstream.git>
! [remote rejected] HEAD -> refs/for/master/topic (proc-receive failed to report status)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'

160
third_party/git/t/t5411/test-0014-bad-protocol--porcelain.sh vendored Normal file
View file

@ -0,0 +1,160 @@
test_expect_success "setup proc-receive hook (unknown version, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v --version 2
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic(A)
test_expect_success "proc-receive: bad protocol (unknown version, $PROTOCOL/porcelain)" '
test_must_fail git -C workbench push --porcelain origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
# Check status report for git-push
sed -n \
-e "/^To / { p; n; p; n; p; }" \
<actual >actual-report &&
cat >expect <<-EOF &&
To <URL/of/upstream.git>
! HEAD:refs/for/master/topic [remote rejected] (fail to run proc-receive hook)
Done
EOF
test_cmp expect actual-report &&
# Check error message from "receive-pack", but ignore unstable fatal error
# message ("remote: fatal: the remote end hung up unexpectedly") which
# is different from the remote HTTP server with different locale settings.
grep "^remote: error:" <actual >actual-error &&
cat >expect <<-EOF &&
remote: error: proc-receive version "2" is not supported
EOF
test_cmp expect actual-error &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (no report, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : next(A) refs/for/master/topic(A)
test_expect_success "proc-receive: bad protocol (no report, $PROTOCOL/porcelain)" '
test_must_fail git -C workbench push --porcelain origin \
HEAD:refs/heads/next \
HEAD:refs/for/master/topic >out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
To <URL/of/upstream.git>
* HEAD:refs/heads/next [new branch]
! HEAD:refs/for/master/topic [remote rejected] (proc-receive failed to report status)
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
<COMMIT-A> refs/heads/next
EOF
test_cmp expect actual
'
# Refs of upstream : master(A) next(A)
# Refs of workbench: master(A) tags/v123
test_expect_success "cleanup ($PROTOCOL/porcelain)" '
git -C "$upstream" update-ref -d refs/heads/next
'
test_expect_success "setup proc-receive hook (no ref, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic
test_expect_success "proc-receive: bad protocol (no ref, $PROTOCOL/porcelain)" '
test_must_fail git -C workbench push --porcelain origin \
HEAD:refs/for/master/topic\
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok
remote: error: proc-receive reported incomplete status line: "ok"
To <URL/of/upstream.git>
! HEAD:refs/for/master/topic [remote rejected] (proc-receive failed to report status)
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (unknown status, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "xx refs/for/master/topic"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic
test_expect_success "proc-receive: bad protocol (unknown status, $PROTOCOL/porcelain)" '
test_must_fail git -C workbench push --porcelain origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> xx refs/for/master/topic
remote: error: proc-receive reported bad status "xx" on ref "refs/for/master/topic"
To <URL/of/upstream.git>
! HEAD:refs/for/master/topic [remote rejected] (proc-receive failed to report status)
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'

67
third_party/git/t/t5411/test-0020-report-ng.sh vendored Normal file
View file

@ -0,0 +1,67 @@
test_expect_success "setup proc-receive hook (ng, no message, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ng refs/for/master/topic"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic
test_expect_success "proc-receive: fail to update (ng, no message, $PROTOCOL)" '
test_must_fail git -C workbench push origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ng refs/for/master/topic
To <URL/of/upstream.git>
! [remote rejected] HEAD -> refs/for/master/topic (failed)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (ng message, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ng refs/for/master/topic error msg"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic
test_expect_success "proc-receive: fail to update (ng, with message, $PROTOCOL)" '
test_must_fail git -C workbench push origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ng refs/for/master/topic error msg
To <URL/of/upstream.git>
! [remote rejected] HEAD -> refs/for/master/topic (error msg)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'

69
third_party/git/t/t5411/test-0021-report-ng--porcelain.sh vendored Normal file
View file

@ -0,0 +1,69 @@
test_expect_success "setup proc-receive hook (ng, no message, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ng refs/for/master/topic"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic
test_expect_success "proc-receive: fail to update (ng, no message, $PROTOCOL/porcelain)" '
test_must_fail git -C workbench push --porcelain origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ng refs/for/master/topic
To <URL/of/upstream.git>
! HEAD:refs/for/master/topic [remote rejected] (failed)
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (ng message, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ng refs/for/master/topic error msg"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic
test_expect_success "proc-receive: fail to update (ng, with message, $PROTOCOL/porcelain)" '
test_must_fail git -C workbench push --porcelain origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ng refs/for/master/topic error msg
To <URL/of/upstream.git>
! HEAD:refs/for/master/topic [remote rejected] (error msg)
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'

45
third_party/git/t/t5411/test-0022-report-unexpect-ref.sh vendored Normal file
View file

@ -0,0 +1,45 @@
test_expect_success "setup proc-receive hook (unexpected ref, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/heads/master"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : (B) refs/for/master/topic
test_expect_success "proc-receive: report unexpected ref ($PROTOCOL)" '
test_must_fail git -C workbench push origin \
$B:refs/heads/master \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/heads/master
remote: error: proc-receive reported status on unexpected ref: refs/heads/master
remote: # post-receive hook
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
To <URL/of/upstream.git>
<OID-A>..<OID-B> <COMMIT-B> -> master
! [remote rejected] HEAD -> refs/for/master/topic (proc-receive failed to report status)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-B> refs/heads/master
EOF
test_cmp expect actual
'
# Refs of upstream : master(B)
# Refs of workbench: master(A) tags/v123
test_expect_success "cleanup ($PROTOCOL)" '
git -C "$upstream" update-ref refs/heads/master $A
'

46
third_party/git/t/t5411/test-0023-report-unexpect-ref--porcelain.sh vendored Normal file
View file

@ -0,0 +1,46 @@
test_expect_success "setup proc-receive hook (unexpected ref, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/heads/master"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : (B) refs/for/master/topic
test_expect_success "proc-receive: report unexpected ref ($PROTOCOL/porcelain)" '
test_must_fail git -C workbench push --porcelain origin \
$B:refs/heads/master \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/heads/master
remote: error: proc-receive reported status on unexpected ref: refs/heads/master
remote: # post-receive hook
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
To <URL/of/upstream.git>
<COMMIT-B>:refs/heads/master <OID-A>..<OID-B>
! HEAD:refs/for/master/topic [remote rejected] (proc-receive failed to report status)
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-B> refs/heads/master
EOF
test_cmp expect actual
'
# Refs of upstream : master(B)
# Refs of workbench: master(A) tags/v123
test_expect_success "cleanup ($PROTOCOL/porcelain)" '
git -C "$upstream" update-ref refs/heads/master $A
'

34
third_party/git/t/t5411/test-0024-report-unknown-ref.sh vendored Normal file
View file

@ -0,0 +1,34 @@
test_expect_success "setup proc-receive hook (unexpected ref, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/a/b/c/my/topic
test_expect_success "proc-receive: report unknown reference ($PROTOCOL)" '
test_must_fail git -C workbench push origin \
HEAD:refs/for/a/b/c/my/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/a/b/c/my/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/a/b/c/my/topic
remote: proc-receive> ok refs/for/master/topic
remote: error: proc-receive reported status on unknown ref: refs/for/master/topic
To <URL/of/upstream.git>
! [remote rejected] HEAD -> refs/for/a/b/c/my/topic (proc-receive failed to report status)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'

35
third_party/git/t/t5411/test-0025-report-unknown-ref--porcelain.sh vendored Normal file
View file

@ -0,0 +1,35 @@
test_expect_success "setup proc-receive hook (unexpected ref, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/a/b/c/my/topic
test_expect_success "proc-receive: report unknown reference ($PROTOCOL/porcelain)" '
test_must_fail git -C workbench push --porcelain origin \
HEAD:refs/for/a/b/c/my/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/a/b/c/my/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/a/b/c/my/topic
remote: proc-receive> ok refs/for/master/topic
remote: error: proc-receive reported status on unknown ref: refs/for/master/topic
To <URL/of/upstream.git>
! HEAD:refs/for/a/b/c/my/topic [remote rejected] (proc-receive failed to report status)
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'

79
third_party/git/t/t5411/test-0026-push-options.sh vendored Normal file
View file

@ -0,0 +1,79 @@
test_expect_success "setup proc-receive hook and disable push-options ($PROTOCOL)" '
git -C "$upstream" config receive.advertisePushOptions false &&
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push -o ... : refs/for/master/topic
test_expect_success "proc-receive: not support push options ($PROTOCOL)" '
test_must_fail git -C workbench push \
-o issue=123 \
-o reviewer=user1 \
origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
test_i18ngrep "fatal: the receiving end does not support push options" \
actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "enable push options ($PROTOCOL)" '
git -C "$upstream" config receive.advertisePushOptions true
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push -o ... : next(A) refs/for/master/topic
test_expect_success "proc-receive: push with options ($PROTOCOL)" '
git -C workbench push \
--atomic \
-o issue=123 \
-o reviewer=user1 \
origin \
HEAD:refs/heads/next \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive: atomic push_options
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive< issue=123
remote: proc-receive< reviewer=user1
remote: proc-receive> ok refs/for/master/topic
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
To <URL/of/upstream.git>
* [new branch] HEAD -> next
* [new reference] HEAD -> refs/for/master/topic
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
<COMMIT-A> refs/heads/next
EOF
test_cmp expect actual
'
# Refs of upstream : master(A) next(A)
# Refs of workbench: master(A) tags/v123
test_expect_success "cleanup ($PROTOCOL)" '
git -C "$upstream" update-ref -d refs/heads/next
'

82
third_party/git/t/t5411/test-0027-push-options--porcelain.sh vendored Normal file
View file

@ -0,0 +1,82 @@
test_expect_success "setup proc-receive hook and disable push-options ($PROTOCOL/porcelain)" '
git -C "$upstream" config receive.advertisePushOptions false &&
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push -o ... : refs/for/master/topic
test_expect_success "proc-receive: not support push options ($PROTOCOL/porcelain)" '
test_must_fail git -C workbench push \
--porcelain \
-o issue=123 \
-o reviewer=user1 \
origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
test_i18ngrep "fatal: the receiving end does not support push options" \
actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "enable push options ($PROTOCOL/porcelain)" '
git -C "$upstream" config receive.advertisePushOptions true
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push -o ... : next(A) refs/for/master/topic
test_expect_success "proc-receive: push with options ($PROTOCOL/porcelain)" '
git -C workbench push \
--porcelain \
--atomic \
-o issue=123 \
-o reviewer=user1 \
origin \
HEAD:refs/heads/next \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive: atomic push_options
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive< issue=123
remote: proc-receive< reviewer=user1
remote: proc-receive> ok refs/for/master/topic
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
To <URL/of/upstream.git>
* HEAD:refs/heads/next [new branch]
* HEAD:refs/for/master/topic [new reference]
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
<COMMIT-A> refs/heads/next
EOF
test_cmp expect actual
'
# Refs of upstream : master(A) next(A)
# Refs of workbench: master(A) tags/v123
test_expect_success "cleanup ($PROTOCOL/porcelain)" '
git -C "$upstream" update-ref -d refs/heads/next
'

35
third_party/git/t/t5411/test-0030-report-ok.sh vendored Normal file
View file

@ -0,0 +1,35 @@
test_expect_success "setup proc-receive hook (ok, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic
test_expect_success "proc-receive: ok ($PROTOCOL)" '
git -C workbench push origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
To <URL/of/upstream.git>
* [new reference] HEAD -> refs/for/master/topic
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'

36
third_party/git/t/t5411/test-0031-report-ok--porcelain.sh vendored Normal file
View file

@ -0,0 +1,36 @@
test_expect_success "setup proc-receive hook (ok, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic
test_expect_success "proc-receive: ok ($PROTOCOL/porcelain)" '
git -C workbench push --porcelain origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
To <URL/of/upstream.git>
* HEAD:refs/for/master/topic [new reference]
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'

256
third_party/git/t/t5411/test-0032-report-with-options.sh vendored Normal file
View file

@ -0,0 +1,256 @@
test_expect_success "setup proc-receive hook (option without matching ok, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "option refname refs/pull/123/head" \
-r "option old-oid $B"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/next/topic(A) refs/for/a/b/c/topic(A) refs/for/master/topic(A)
test_expect_success "proc-receive: report option without matching ok ($PROTOCOL)" '
test_must_fail git -C workbench push origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> option refname refs/pull/123/head
remote: proc-receive> option old-oid <COMMIT-B>
remote: error: proc-receive reported "option" without a matching "ok/ng" directive
To <URL/of/upstream.git>
! [remote rejected] HEAD -> refs/for/master/topic (proc-receive failed to report status)
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (option refname, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option refname refs/pull/123/head"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/next/topic(A) refs/for/a/b/c/topic(A) refs/for/master/topic(A)
test_expect_success "proc-receive: report option refname ($PROTOCOL)" '
git -C workbench push origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/pull/123/head
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/pull/123/head
To <URL/of/upstream.git>
* [new reference] HEAD -> refs/pull/123/head
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (option refname and forced-update, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option refname refs/pull/123/head" \
-r "option forced-update"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/next/topic(A) refs/for/a/b/c/topic(A) refs/for/master/topic(A)
test_expect_success "proc-receive: report option refname and forced-update ($PROTOCOL)" '
git -C workbench push origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/pull/123/head
remote: proc-receive> option forced-update
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/pull/123/head
To <URL/of/upstream.git>
* [new reference] HEAD -> refs/pull/123/head
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (option refname and old-oid, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option refname refs/pull/123/head" \
-r "option old-oid $B"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/next/topic(A) refs/for/a/b/c/topic(A) refs/for/master/topic(A)
test_expect_success "proc-receive: report option refname and old-oid ($PROTOCOL)" '
git -C workbench push origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/pull/123/head
remote: proc-receive> option old-oid <COMMIT-B>
remote: # post-receive hook
remote: post-receive< <COMMIT-B> <COMMIT-A> refs/pull/123/head
To <URL/of/upstream.git>
<OID-B>..<OID-A> HEAD -> refs/pull/123/head
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (option old-oid, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option old-oid $B"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/next/topic(A) refs/for/a/b/c/topic(A) refs/for/master/topic(A)
test_expect_success "proc-receive: report option old-oid ($PROTOCOL)" '
git -C workbench push origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option old-oid <COMMIT-B>
remote: # post-receive hook
remote: post-receive< <COMMIT-B> <COMMIT-A> refs/for/master/topic
To <URL/of/upstream.git>
<OID-B>..<OID-A> HEAD -> refs/for/master/topic
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (option old-oid and new-oid, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option old-oid $A" \
-r "option new-oid $B"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/next/topic(A) refs/for/a/b/c/topic(A) refs/for/master/topic(A)
test_expect_success "proc-receive: report option old-oid and new-oid ($PROTOCOL)" '
git -C workbench push origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option old-oid <COMMIT-A>
remote: proc-receive> option new-oid <COMMIT-B>
remote: # post-receive hook
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/for/master/topic
To <URL/of/upstream.git>
<OID-A>..<OID-B> HEAD -> refs/for/master/topic
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (report with multiple rewrites, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/a/b/c/topic" \
-r "ok refs/for/next/topic" \
-r "option refname refs/pull/123/head" \
-r "ok refs/for/master/topic" \
-r "option refname refs/pull/124/head" \
-r "option old-oid $B" \
-r "option forced-update" \
-r "option new-oid $A"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/next/topic(A) refs/for/a/b/c/topic(A) refs/for/master/topic(A)
test_expect_success "proc-receive: report with multiple rewrites ($PROTOCOL)" '
git -C workbench push origin \
HEAD:refs/for/next/topic \
HEAD:refs/for/a/b/c/topic \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/a/b/c/topic
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/a/b/c/topic
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/a/b/c/topic
remote: proc-receive> ok refs/for/next/topic
remote: proc-receive> option refname refs/pull/123/head
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/pull/124/head
remote: proc-receive> option old-oid <COMMIT-B>
remote: proc-receive> option forced-update
remote: proc-receive> option new-oid <COMMIT-A>
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/pull/123/head
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/for/a/b/c/topic
remote: post-receive< <COMMIT-B> <COMMIT-A> refs/pull/124/head
To <URL/of/upstream.git>
* [new reference] HEAD -> refs/pull/123/head
* [new reference] HEAD -> refs/for/a/b/c/topic
+ <OID-B>...<OID-A> HEAD -> refs/pull/124/head (forced update)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'

265
third_party/git/t/t5411/test-0033-report-with-options--porcelain.sh vendored Normal file
View file

@ -0,0 +1,265 @@
test_expect_success "setup proc-receive hook (option without matching ok, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "option refname refs/pull/123/head" \
-r "option old-oid $B"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/next/topic(A) refs/for/a/b/c/topic(A) refs/for/master/topic(A)
test_expect_success "proc-receive: report option without matching ok ($PROTOCOL/porcelain)" '
test_must_fail git -C workbench push --porcelain origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> option refname refs/pull/123/head
remote: proc-receive> option old-oid <COMMIT-B>
remote: error: proc-receive reported "option" without a matching "ok/ng" directive
To <URL/of/upstream.git>
! HEAD:refs/for/master/topic [remote rejected] (proc-receive failed to report status)
Done
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (option refname, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option refname refs/pull/123/head"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/next/topic(A) refs/for/a/b/c/topic(A) refs/for/master/topic(A)
test_expect_success "proc-receive: report option refname ($PROTOCOL/porcelain)" '
git -C workbench push --porcelain origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/pull/123/head
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/pull/123/head
To <URL/of/upstream.git>
* HEAD:refs/pull/123/head [new reference]
Done
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (option refname and forced-update, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option refname refs/pull/123/head" \
-r "option forced-update"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/next/topic(A) refs/for/a/b/c/topic(A) refs/for/master/topic(A)
test_expect_success "proc-receive: report option refname and forced-update ($PROTOCOL/porcelain)" '
git -C workbench push --porcelain origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/pull/123/head
remote: proc-receive> option forced-update
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/pull/123/head
To <URL/of/upstream.git>
* HEAD:refs/pull/123/head [new reference]
Done
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (option refname and old-oid, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option refname refs/pull/123/head" \
-r "option old-oid $B"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/next/topic(A) refs/for/a/b/c/topic(A) refs/for/master/topic(A)
test_expect_success "proc-receive: report option refname and old-oid ($PROTOCOL/porcelain)" '
git -C workbench push --porcelain origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/pull/123/head
remote: proc-receive> option old-oid <COMMIT-B>
remote: # post-receive hook
remote: post-receive< <COMMIT-B> <COMMIT-A> refs/pull/123/head
To <URL/of/upstream.git>
HEAD:refs/pull/123/head <OID-B>..<OID-A>
Done
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (option old-oid, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option old-oid $B"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/next/topic(A) refs/for/a/b/c/topic(A) refs/for/master/topic(A)
test_expect_success "proc-receive: report option old-oid ($PROTOCOL/porcelain)" '
git -C workbench push --porcelain origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option old-oid <COMMIT-B>
remote: # post-receive hook
remote: post-receive< <COMMIT-B> <COMMIT-A> refs/for/master/topic
To <URL/of/upstream.git>
HEAD:refs/for/master/topic <OID-B>..<OID-A>
Done
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (option old-oid and new-oid, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option old-oid $A" \
-r "option new-oid $B"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/next/topic(A) refs/for/a/b/c/topic(A) refs/for/master/topic(A)
test_expect_success "proc-receive: report option old-oid and new-oid ($PROTOCOL/porcelain)" '
git -C workbench push --porcelain origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option old-oid <COMMIT-A>
remote: proc-receive> option new-oid <COMMIT-B>
remote: # post-receive hook
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/for/master/topic
To <URL/of/upstream.git>
HEAD:refs/for/master/topic <OID-A>..<OID-B>
Done
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (report with multiple rewrites, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/a/b/c/topic" \
-r "ok refs/for/next/topic" \
-r "option refname refs/pull/123/head" \
-r "ok refs/for/master/topic" \
-r "option refname refs/pull/124/head" \
-r "option old-oid $B" \
-r "option forced-update" \
-r "option new-oid $A"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/next/topic(A) refs/for/a/b/c/topic(A) refs/for/master/topic(A)
test_expect_success "proc-receive: report with multiple rewrites ($PROTOCOL/porcelain)" '
git -C workbench push --porcelain origin \
HEAD:refs/for/next/topic \
HEAD:refs/for/a/b/c/topic \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/a/b/c/topic
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/a/b/c/topic
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/a/b/c/topic
remote: proc-receive> ok refs/for/next/topic
remote: proc-receive> option refname refs/pull/123/head
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/pull/124/head
remote: proc-receive> option old-oid <COMMIT-B>
remote: proc-receive> option forced-update
remote: proc-receive> option new-oid <COMMIT-A>
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/pull/123/head
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/for/a/b/c/topic
remote: post-receive< <COMMIT-B> <COMMIT-A> refs/pull/124/head
To <URL/of/upstream.git>
* HEAD:refs/pull/123/head [new reference]
* HEAD:refs/for/a/b/c/topic [new reference]
+ HEAD:refs/pull/124/head <OID-B>...<OID-A> (forced update)
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'

44
third_party/git/t/t5411/test-0034-report-ft.sh vendored Normal file
View file

@ -0,0 +1,44 @@
test_expect_success "setup proc-receive hook (ft, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option fall-through"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic(B)
test_expect_success "proc-receive: fall throught, let receive-pack to execute ($PROTOCOL)" '
git -C workbench push origin \
$B:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-B> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-B> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option fall-through
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-B> refs/for/master/topic
To <URL/of/upstream.git>
* [new reference] <COMMIT-B> -> refs/for/master/topic
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-B> refs/for/master/topic
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
# Refs of upstream : master(A) refs/for/master/topic(A)
# Refs of workbench: master(A) tags/v123
test_expect_success "cleanup ($PROTOCOL)" '
git -C "$upstream" update-ref -d refs/for/master/topic
'

45
third_party/git/t/t5411/test-0035-report-ft--porcelain.sh vendored Normal file
View file

@ -0,0 +1,45 @@
test_expect_success "setup proc-receive hook (fall-through, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option fall-through"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic(B)
test_expect_success "proc-receive: fall throught, let receive-pack to execute ($PROTOCOL/porcelain)" '
git -C workbench push --porcelain origin \
$B:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-B> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-B> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option fall-through
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-B> refs/for/master/topic
To <URL/of/upstream.git>
* <COMMIT-B>:refs/for/master/topic [new reference]
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-B> refs/for/master/topic
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
# Refs of upstream : master(A) refs/for/master/topic(A)
# Refs of workbench: master(A) tags/v123
test_expect_success "cleanup ($PROTOCOL/porcelain)" '
git -C "$upstream" update-ref -d refs/for/master/topic
'

227
third_party/git/t/t5411/test-0036-report-multi-rewrite-for-one-ref.sh vendored Normal file
View file

@ -0,0 +1,227 @@
test_expect_success "setup git config for remote-tracking of special refs" '
(
cd workbench &&
if ! git config --get-all remote.origin.fetch | grep refs/for/
then
git config --add remote.origin.fetch \
"+refs/for/*:refs/t/for/*" &&
git config --add remote.origin.fetch \
"+refs/pull/*:refs/t/pull/*" &&
git config --add remote.origin.fetch \
"+refs/changes/*:refs/t/changes/*"
fi
)
'
test_expect_success "setup proc-receive hook (multiple rewrites for one ref, no refname for the 1st rewrite, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option old-oid $A" \
-r "option new-oid $B" \
-r "ok refs/for/master/topic" \
-r "option refname refs/changes/24/124/1" \
-r "option old-oid $ZERO_OID" \
-r "option new-oid $A" \
-r "ok refs/for/master/topic" \
-r "option refname refs/changes/25/125/1" \
-r "option old-oid $A" \
-r "option new-oid $B"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic(A)
test_expect_success "proc-receive: multiple rewrite for one ref, no refname for the 1st rewrite ($PROTOCOL)" '
git -C workbench push origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option old-oid <COMMIT-A>
remote: proc-receive> option new-oid <COMMIT-B>
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/changes/24/124/1
remote: proc-receive> option old-oid <ZERO-OID>
remote: proc-receive> option new-oid <COMMIT-A>
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/changes/25/125/1
remote: proc-receive> option old-oid <COMMIT-A>
remote: proc-receive> option new-oid <COMMIT-B>
remote: # post-receive hook
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/for/master/topic
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/changes/24/124/1
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/changes/25/125/1
To <URL/of/upstream.git>
<OID-A>..<OID-B> HEAD -> refs/for/master/topic
* [new reference] HEAD -> refs/changes/24/124/1
<OID-A>..<OID-B> HEAD -> refs/changes/25/125/1
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "proc-receive: check remote-tracking #1 ($PROTOCOL)" '
git -C workbench show-ref |
grep -v -e refs/remotes -e refs/heads -e refs/tags >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/t/changes/24/124/1
<COMMIT-B> refs/t/changes/25/125/1
<COMMIT-B> refs/t/for/master/topic
EOF
test_cmp expect actual &&
git -C workbench update-ref -d refs/t/for/master/topic &&
git -C workbench update-ref -d refs/t/changes/24/124/1 &&
git -C workbench update-ref -d refs/t/changes/25/125/1
'
test_expect_success "setup proc-receive hook (multiple rewrites for one ref, no refname for the 2nd rewrite, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option refname refs/changes/24/124/1" \
-r "option old-oid $ZERO_OID" \
-r "option new-oid $A" \
-r "ok refs/for/master/topic" \
-r "option old-oid $A" \
-r "option new-oid $B" \
-r "ok refs/for/master/topic" \
-r "option refname refs/changes/25/125/1" \
-r "option old-oid $B" \
-r "option new-oid $A" \
-r "option forced-update"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic(A)
test_expect_success "proc-receive: multiple rewrites for one ref, no refname for the 2nd rewrite ($PROTOCOL)" '
git -C workbench push origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/changes/24/124/1
remote: proc-receive> option old-oid <ZERO-OID>
remote: proc-receive> option new-oid <COMMIT-A>
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option old-oid <COMMIT-A>
remote: proc-receive> option new-oid <COMMIT-B>
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/changes/25/125/1
remote: proc-receive> option old-oid <COMMIT-B>
remote: proc-receive> option new-oid <COMMIT-A>
remote: proc-receive> option forced-update
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/changes/24/124/1
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/for/master/topic
remote: post-receive< <COMMIT-B> <COMMIT-A> refs/changes/25/125/1
To <URL/of/upstream.git>
* [new reference] HEAD -> refs/changes/24/124/1
<OID-A>..<OID-B> HEAD -> refs/for/master/topic
+ <OID-B>...<OID-A> HEAD -> refs/changes/25/125/1 (forced update)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "proc-receive: check remote-tracking #2 ($PROTOCOL)" '
git -C workbench show-ref |
grep -v -e refs/remotes -e refs/heads -e refs/tags >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/t/changes/24/124/1
<COMMIT-A> refs/t/changes/25/125/1
<COMMIT-B> refs/t/for/master/topic
EOF
test_cmp expect actual &&
git -C workbench update-ref -d refs/t/for/master/topic &&
git -C workbench update-ref -d refs/t/changes/24/124/1 &&
git -C workbench update-ref -d refs/t/changes/25/125/1
'
test_expect_success "setup proc-receive hook (multiple rewrites for one ref, $PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option refname refs/changes/23/123/1" \
-r "ok refs/for/master/topic" \
-r "option refname refs/changes/24/124/2" \
-r "option old-oid $A" \
-r "option new-oid $B"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic(A)
test_expect_success "proc-receive: multiple rewrites for one ref ($PROTOCOL)" '
git -C workbench push origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/changes/23/123/1
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/changes/24/124/2
remote: proc-receive> option old-oid <COMMIT-A>
remote: proc-receive> option new-oid <COMMIT-B>
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/changes/23/123/1
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/changes/24/124/2
To <URL/of/upstream.git>
* [new reference] HEAD -> refs/changes/23/123/1
<OID-A>..<OID-B> HEAD -> refs/changes/24/124/2
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "proc-receive: check remote-tracking #3 ($PROTOCOL)" '
git -C workbench show-ref |
grep -v -e refs/remotes -e refs/heads -e refs/tags >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/t/changes/23/123/1
<COMMIT-B> refs/t/changes/24/124/2
EOF
test_cmp expect actual &&
git -C workbench update-ref -d refs/t/changes/24/124/1 &&
git -C workbench update-ref -d refs/t/changes/25/125/2
'

172
third_party/git/t/t5411/test-0037-report-multi-rewrite-for-one-ref--porcelain.sh vendored Normal file
View file

@ -0,0 +1,172 @@
test_expect_success "setup proc-receive hook (multiple rewrites for one ref, no refname for the 1st rewrite, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option old-oid $A" \
-r "option new-oid $B" \
-r "ok refs/for/master/topic" \
-r "option refname refs/changes/24/124/1" \
-r "option old-oid $ZERO_OID" \
-r "option new-oid $A" \
-r "ok refs/for/master/topic" \
-r "option refname refs/changes/25/125/1" \
-r "option old-oid $A" \
-r "option new-oid $B"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic(A)
test_expect_success "proc-receive: multiple rewrite for one ref, no refname for the 1st rewrite ($PROTOCOL/porcelain)" '
git -C workbench push --porcelain origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option old-oid <COMMIT-A>
remote: proc-receive> option new-oid <COMMIT-B>
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/changes/24/124/1
remote: proc-receive> option old-oid <ZERO-OID>
remote: proc-receive> option new-oid <COMMIT-A>
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/changes/25/125/1
remote: proc-receive> option old-oid <COMMIT-A>
remote: proc-receive> option new-oid <COMMIT-B>
remote: # post-receive hook
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/for/master/topic
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/changes/24/124/1
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/changes/25/125/1
To <URL/of/upstream.git>
HEAD:refs/for/master/topic <OID-A>..<OID-B>
* HEAD:refs/changes/24/124/1 [new reference]
HEAD:refs/changes/25/125/1 <OID-A>..<OID-B>
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (multiple rewrites for one ref, no refname for the 2nd rewrite, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option refname refs/changes/24/124/1" \
-r "option old-oid $ZERO_OID" \
-r "option new-oid $A" \
-r "ok refs/for/master/topic" \
-r "option old-oid $A" \
-r "option new-oid $B" \
-r "ok refs/for/master/topic" \
-r "option refname refs/changes/25/125/1" \
-r "option old-oid $B" \
-r "option new-oid $A" \
-r "option forced-update"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic(A)
test_expect_success "proc-receive: multiple rewrites for one ref, no refname for the 2nd rewrite ($PROTOCOL/porcelain)" '
git -C workbench push --porcelain origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/changes/24/124/1
remote: proc-receive> option old-oid <ZERO-OID>
remote: proc-receive> option new-oid <COMMIT-A>
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option old-oid <COMMIT-A>
remote: proc-receive> option new-oid <COMMIT-B>
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/changes/25/125/1
remote: proc-receive> option old-oid <COMMIT-B>
remote: proc-receive> option new-oid <COMMIT-A>
remote: proc-receive> option forced-update
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/changes/24/124/1
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/for/master/topic
remote: post-receive< <COMMIT-B> <COMMIT-A> refs/changes/25/125/1
To <URL/of/upstream.git>
* HEAD:refs/changes/24/124/1 [new reference]
HEAD:refs/for/master/topic <OID-A>..<OID-B>
+ HEAD:refs/changes/25/125/1 <OID-B>...<OID-A> (forced update)
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook (multiple rewrites for one ref, $PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/master/topic" \
-r "option refname refs/changes/23/123/1" \
-r "ok refs/for/master/topic" \
-r "option refname refs/changes/24/124/2" \
-r "option old-oid $A" \
-r "option new-oid $B"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : refs/for/master/topic(A)
test_expect_success "proc-receive: multiple rewrites for one ref ($PROTOCOL/porcelain)" '
git -C workbench push --porcelain origin \
HEAD:refs/for/master/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/changes/23/123/1
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/changes/24/124/2
remote: proc-receive> option old-oid <COMMIT-A>
remote: proc-receive> option new-oid <COMMIT-B>
remote: # post-receive hook
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/changes/23/123/1
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/changes/24/124/2
To <URL/of/upstream.git>
* HEAD:refs/changes/23/123/1 [new reference]
HEAD:refs/changes/24/124/2 <OID-A>..<OID-B>
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'

89
third_party/git/t/t5411/test-0038-report-mixed-refs.sh vendored Normal file
View file

@ -0,0 +1,89 @@
test_expect_success "setup proc-receive hook ($PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/next/topic2" \
-r "ng refs/for/next/topic1 fail to call Web API" \
-r "ok refs/for/master/topic" \
-r "option refname refs/for/master/topic" \
-r "option old-oid $A" \
-r "option new-oid $B"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : (B) bar(A) baz(A) refs/for/next/topic(A) foo(A) refs/for/master/topic(A)
test_expect_success "proc-receive: report update of mixed refs ($PROTOCOL)" '
test_must_fail git -C workbench push origin \
$B:refs/heads/master \
HEAD:refs/heads/bar \
HEAD:refs/heads/baz \
HEAD:refs/for/next/topic2 \
HEAD:refs/for/next/topic1 \
HEAD:refs/heads/foo \
HEAD:refs/for/master/topic \
HEAD:refs/for/next/topic3 \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/bar
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/baz
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic2
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic1
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/foo
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic3
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic2
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic1
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic3
remote: proc-receive> ok refs/for/next/topic2
remote: proc-receive> ng refs/for/next/topic1 fail to call Web API
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/for/master/topic
remote: proc-receive> option old-oid <COMMIT-A>
remote: proc-receive> option new-oid <COMMIT-B>
remote: # post-receive hook
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/heads/bar
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/heads/baz
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic2
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/heads/foo
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/for/master/topic
To <URL/of/upstream.git>
<OID-A>..<OID-B> <COMMIT-B> -> master
* [new branch] HEAD -> bar
* [new branch] HEAD -> baz
* [new reference] HEAD -> refs/for/next/topic2
* [new branch] HEAD -> foo
<OID-A>..<OID-B> HEAD -> refs/for/master/topic
! [remote rejected] HEAD -> refs/for/next/topic1 (fail to call Web API)
! [remote rejected] HEAD -> refs/for/next/topic3 (proc-receive failed to report status)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/bar
<COMMIT-A> refs/heads/baz
<COMMIT-A> refs/heads/foo
<COMMIT-B> refs/heads/master
EOF
test_cmp expect actual
'
# Refs of upstream : master(B) foo(A) bar(A)) baz(A)
# Refs of workbench: master(A) tags/v123
test_expect_success "cleanup ($PROTOCOL)" '
(
cd "$upstream" &&
git update-ref refs/heads/master $A &&
git update-ref -d refs/heads/foo &&
git update-ref -d refs/heads/bar &&
git update-ref -d refs/heads/baz
)
'

91
third_party/git/t/t5411/test-0039-report-mixed-refs--porcelain.sh vendored Normal file
View file

@ -0,0 +1,91 @@
test_expect_success "setup proc-receive hook ($PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/for/next/topic2" \
-r "ng refs/for/next/topic1 fail to call Web API" \
-r "ok refs/for/master/topic" \
-r "option refname refs/for/master/topic" \
-r "option old-oid $A" \
-r "option new-oid $B"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : (B) bar(A) baz(A) refs/for/next/topic(A) foo(A) refs/for/master/topic(A)
test_expect_success "proc-receive: report update of mixed refs ($PROTOCOL/porcelain)" '
test_must_fail git -C workbench push --porcelain origin \
$B:refs/heads/master \
HEAD:refs/heads/bar \
HEAD:refs/heads/baz \
HEAD:refs/for/next/topic2 \
HEAD:refs/for/next/topic1 \
HEAD:refs/heads/foo \
HEAD:refs/for/master/topic \
HEAD:refs/for/next/topic3 \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/bar
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/baz
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic2
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic1
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/foo
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic3
remote: # proc-receive hook
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic2
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic1
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic3
remote: proc-receive> ok refs/for/next/topic2
remote: proc-receive> ng refs/for/next/topic1 fail to call Web API
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/for/master/topic
remote: proc-receive> option old-oid <COMMIT-A>
remote: proc-receive> option new-oid <COMMIT-B>
remote: # post-receive hook
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/heads/bar
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/heads/baz
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic2
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/heads/foo
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/for/master/topic
To <URL/of/upstream.git>
<COMMIT-B>:refs/heads/master <OID-A>..<OID-B>
* HEAD:refs/heads/bar [new branch]
* HEAD:refs/heads/baz [new branch]
* HEAD:refs/for/next/topic2 [new reference]
* HEAD:refs/heads/foo [new branch]
HEAD:refs/for/master/topic <OID-A>..<OID-B>
! HEAD:refs/for/next/topic1 [remote rejected] (fail to call Web API)
! HEAD:refs/for/next/topic3 [remote rejected] (proc-receive failed to report status)
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/bar
<COMMIT-A> refs/heads/baz
<COMMIT-A> refs/heads/foo
<COMMIT-B> refs/heads/master
EOF
test_cmp expect actual
'
# Refs of upstream : master(B) foo(A) bar(A)) baz(A)
# Refs of workbench: master(A) tags/v123
test_expect_success "cleanup ($PROTOCOL/porcelain)" '
(
cd "$upstream" &&
git update-ref refs/heads/master $A &&
git update-ref -d refs/heads/foo &&
git update-ref -d refs/heads/bar &&
git update-ref -d refs/heads/baz
)
'

113
third_party/git/t/t5411/test-0040-process-all-refs.sh vendored Normal file
View file

@ -0,0 +1,113 @@
test_expect_success "config receive.procReceiveRefs = refs ($PROTOCOL)" '
git -C "$upstream" config --unset-all receive.procReceiveRefs &&
git -C "$upstream" config --add receive.procReceiveRefs refs
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
test_expect_success "setup upstream branches ($PROTOCOL)" '
(
cd "$upstream" &&
git update-ref refs/heads/master $B &&
git update-ref refs/heads/foo $A &&
git update-ref refs/heads/bar $A &&
git update-ref refs/heads/baz $A
)
'
test_expect_success "setup proc-receive hook ($PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/heads/master" \
-r "option fall-through" \
-r "ok refs/heads/foo" \
-r "option fall-through" \
-r "ok refs/heads/bar" \
-r "option fall-through" \
-r "ok refs/for/master/topic" \
-r "option refname refs/pull/123/head" \
-r "option old-oid $A" \
-r "option new-oid $B" \
-r "ok refs/for/next/topic" \
-r "option refname refs/pull/124/head" \
-r "option old-oid $B" \
-r "option new-oid $A" \
-r "option forced-update"
EOF
'
# Refs of upstream : master(B) foo(A) bar(A)) baz(A)
# Refs of workbench: master(A) tags/v123
# git push -f : master(A) (NULL) (B) refs/for/master/topic(A) refs/for/next/topic(A)
test_expect_success "proc-receive: process all refs ($PROTOCOL)" '
git -C workbench push -f origin \
HEAD:refs/heads/master \
:refs/heads/foo \
$B:refs/heads/bar \
HEAD:refs/for/master/topic \
HEAD:refs/for/next/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <COMMIT-A> <COMMIT-B> refs/heads/bar
remote: pre-receive< <COMMIT-A> <ZERO-OID> refs/heads/foo
remote: pre-receive< <COMMIT-B> <COMMIT-A> refs/heads/master
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic
remote: # proc-receive hook
remote: proc-receive< <COMMIT-A> <COMMIT-B> refs/heads/bar
remote: proc-receive< <COMMIT-A> <ZERO-OID> refs/heads/foo
remote: proc-receive< <COMMIT-B> <COMMIT-A> refs/heads/master
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic
remote: proc-receive> ok refs/heads/master
remote: proc-receive> option fall-through
remote: proc-receive> ok refs/heads/foo
remote: proc-receive> option fall-through
remote: proc-receive> ok refs/heads/bar
remote: proc-receive> option fall-through
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/pull/123/head
remote: proc-receive> option old-oid <COMMIT-A>
remote: proc-receive> option new-oid <COMMIT-B>
remote: proc-receive> ok refs/for/next/topic
remote: proc-receive> option refname refs/pull/124/head
remote: proc-receive> option old-oid <COMMIT-B>
remote: proc-receive> option new-oid <COMMIT-A>
remote: proc-receive> option forced-update
remote: # post-receive hook
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/heads/bar
remote: post-receive< <COMMIT-A> <ZERO-OID> refs/heads/foo
remote: post-receive< <COMMIT-B> <COMMIT-A> refs/heads/master
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/pull/123/head
remote: post-receive< <COMMIT-B> <COMMIT-A> refs/pull/124/head
To <URL/of/upstream.git>
<OID-A>..<OID-B> <COMMIT-B> -> bar
- [deleted] foo
+ <OID-B>...<OID-A> HEAD -> master (forced update)
<OID-A>..<OID-B> HEAD -> refs/pull/123/head
+ <OID-B>...<OID-A> HEAD -> refs/pull/124/head (forced update)
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-B> refs/heads/bar
<COMMIT-A> refs/heads/baz
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
# Refs of upstream : master(A) bar(A) baz(B)
# Refs of workbench: master(A) tags/v123
test_expect_success "cleanup ($PROTOCOL)" '
(
cd "$upstream" &&
git update-ref -d refs/heads/bar &&
git update-ref -d refs/heads/baz
)
'

114
third_party/git/t/t5411/test-0041-process-all-refs--porcelain.sh vendored Normal file
View file

@ -0,0 +1,114 @@
test_expect_success "config receive.procReceiveRefs = refs ($PROTOCOL/porcelain)" '
git -C "$upstream" config --unset-all receive.procReceiveRefs &&
git -C "$upstream" config --add receive.procReceiveRefs refs
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
test_expect_success "setup upstream branches ($PROTOCOL/porcelain)" '
(
cd "$upstream" &&
git update-ref refs/heads/master $B &&
git update-ref refs/heads/foo $A &&
git update-ref refs/heads/bar $A &&
git update-ref refs/heads/baz $A
)
'
test_expect_success "setup proc-receive hook ($PROTOCOL/porcelain)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/heads/master" \
-r "option fall-through" \
-r "ok refs/heads/foo" \
-r "option fall-through" \
-r "ok refs/heads/bar" \
-r "option fall-through" \
-r "ok refs/for/master/topic" \
-r "option refname refs/pull/123/head" \
-r "option old-oid $A" \
-r "option new-oid $B" \
-r "ok refs/for/next/topic" \
-r "option refname refs/pull/124/head" \
-r "option old-oid $B" \
-r "option new-oid $A" \
-r "option forced-update"
EOF
'
# Refs of upstream : master(B) foo(A) bar(A)) baz(A)
# Refs of workbench: master(A) tags/v123
# git push -f : master(A) (NULL) (B) refs/for/master/topic(A) refs/for/next/topic(A)
test_expect_success "proc-receive: process all refs ($PROTOCOL/porcelain)" '
git -C workbench push --porcelain -f origin \
HEAD:refs/heads/master \
:refs/heads/foo \
$B:refs/heads/bar \
HEAD:refs/for/master/topic \
HEAD:refs/for/next/topic \
>out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <COMMIT-A> <COMMIT-B> refs/heads/bar
remote: pre-receive< <COMMIT-A> <ZERO-OID> refs/heads/foo
remote: pre-receive< <COMMIT-B> <COMMIT-A> refs/heads/master
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic
remote: # proc-receive hook
remote: proc-receive< <COMMIT-A> <COMMIT-B> refs/heads/bar
remote: proc-receive< <COMMIT-A> <ZERO-OID> refs/heads/foo
remote: proc-receive< <COMMIT-B> <COMMIT-A> refs/heads/master
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/master/topic
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/for/next/topic
remote: proc-receive> ok refs/heads/master
remote: proc-receive> option fall-through
remote: proc-receive> ok refs/heads/foo
remote: proc-receive> option fall-through
remote: proc-receive> ok refs/heads/bar
remote: proc-receive> option fall-through
remote: proc-receive> ok refs/for/master/topic
remote: proc-receive> option refname refs/pull/123/head
remote: proc-receive> option old-oid <COMMIT-A>
remote: proc-receive> option new-oid <COMMIT-B>
remote: proc-receive> ok refs/for/next/topic
remote: proc-receive> option refname refs/pull/124/head
remote: proc-receive> option old-oid <COMMIT-B>
remote: proc-receive> option new-oid <COMMIT-A>
remote: proc-receive> option forced-update
remote: # post-receive hook
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/heads/bar
remote: post-receive< <COMMIT-A> <ZERO-OID> refs/heads/foo
remote: post-receive< <COMMIT-B> <COMMIT-A> refs/heads/master
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/pull/123/head
remote: post-receive< <COMMIT-B> <COMMIT-A> refs/pull/124/head
To <URL/of/upstream.git>
<COMMIT-B>:refs/heads/bar <OID-A>..<OID-B>
- :refs/heads/foo [deleted]
+ HEAD:refs/heads/master <OID-B>...<OID-A> (forced update)
HEAD:refs/pull/123/head <OID-A>..<OID-B>
+ HEAD:refs/pull/124/head <OID-B>...<OID-A> (forced update)
Done
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-B> refs/heads/bar
<COMMIT-A> refs/heads/baz
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
# Refs of upstream : master(A) bar(A) baz(B)
# Refs of workbench: master(A) tags/v123
test_expect_success "cleanup ($PROTOCOL/porcelain)" '
(
cd "$upstream" &&
git update-ref -d refs/heads/bar &&
git update-ref -d refs/heads/baz
)
'

135
third_party/git/t/t5411/test-0050-proc-receive-refs-with-modifiers.sh vendored Normal file
View file

@ -0,0 +1,135 @@
test_expect_success "config receive.procReceiveRefs with modifiers ($PROTOCOL)" '
(
cd "$upstream" &&
git config --unset-all receive.procReceiveRefs &&
git config --add receive.procReceiveRefs m:refs/heads/master &&
git config --add receive.procReceiveRefs ad:refs/heads &&
git config --add receive.procReceiveRefs "a!:refs/heads"
)
'
test_expect_success "setup proc-receive hook ($PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/heads/master" \
-r "option refname refs/pull/123/head" \
-r "option old-oid $A" \
-r "option new-oid $B" \
-r "ok refs/tags/v123 " \
-r "option refname refs/pull/124/head"
EOF
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
# git push : master(B) tags/v123
test_expect_success "proc-receive: update branch and new tag ($PROTOCOL)" '
git -C workbench push origin \
$B:refs/heads/master \
v123 >out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
remote: pre-receive< <ZERO-OID> <TAG-v123> refs/tags/v123
remote: # proc-receive hook
remote: proc-receive< <COMMIT-A> <COMMIT-B> refs/heads/master
remote: proc-receive< <ZERO-OID> <TAG-v123> refs/tags/v123
remote: proc-receive> ok refs/heads/master
remote: proc-receive> option refname refs/pull/123/head
remote: proc-receive> option old-oid <COMMIT-A>
remote: proc-receive> option new-oid <COMMIT-B>
remote: proc-receive> ok refs/tags/v123
remote: proc-receive> option refname refs/pull/124/head
remote: # post-receive hook
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/pull/123/head
remote: post-receive< <ZERO-OID> <TAG-v123> refs/pull/124/head
To <URL/of/upstream.git>
<OID-A>..<OID-B> <COMMIT-B> -> refs/pull/123/head
* [new reference] v123 -> refs/pull/124/head
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
EOF
test_cmp expect actual
'
# Refs of upstream : master(A)
# Refs of workbench: master(A) tags/v123
test_expect_success "setup upstream: create tags/v123 ($PROTOCOL)" '
git -C "$upstream" update-ref refs/heads/topic $A &&
git -C "$upstream" update-ref refs/tags/v123 $TAG &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
<COMMIT-A> refs/heads/topic
<TAG-v123> refs/tags/v123
EOF
test_cmp expect actual
'
test_expect_success "setup proc-receive hook ($PROTOCOL)" '
write_script "$upstream/hooks/proc-receive" <<-EOF
printf >&2 "# proc-receive hook\n"
test-tool proc-receive -v \
-r "ok refs/heads/master" \
-r "option refname refs/pull/123/head" \
-r "option old-oid $A" \
-r "option new-oid $ZERO_OID" \
-r "ok refs/heads/next" \
-r "option refname refs/pull/124/head" \
-r "option new-oid $A"
EOF
'
# Refs of upstream : master(A) topic(A) tags/v123
# Refs of workbench: master(A) tags/v123
# git push : NULL topic(B) NULL next(A)
test_expect_success "proc-receive: create/delete branch, and delete tag ($PROTOCOL)" '
git -C workbench push origin \
:refs/heads/master \
$B:refs/heads/topic \
$A:refs/heads/next \
:refs/tags/v123 >out 2>&1 &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
remote: # pre-receive hook
remote: pre-receive< <COMMIT-A> <ZERO-OID> refs/heads/master
remote: pre-receive< <COMMIT-A> <COMMIT-B> refs/heads/topic
remote: pre-receive< <TAG-v123> <ZERO-OID> refs/tags/v123
remote: pre-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
remote: # proc-receive hook
remote: proc-receive< <COMMIT-A> <ZERO-OID> refs/heads/master
remote: proc-receive< <ZERO-OID> <COMMIT-A> refs/heads/next
remote: proc-receive> ok refs/heads/master
remote: proc-receive> option refname refs/pull/123/head
remote: proc-receive> option old-oid <COMMIT-A>
remote: proc-receive> option new-oid <ZERO-OID>
remote: proc-receive> ok refs/heads/next
remote: proc-receive> option refname refs/pull/124/head
remote: proc-receive> option new-oid <COMMIT-A>
remote: # post-receive hook
remote: post-receive< <COMMIT-A> <ZERO-OID> refs/pull/123/head
remote: post-receive< <COMMIT-A> <COMMIT-B> refs/heads/topic
remote: post-receive< <TAG-v123> <ZERO-OID> refs/tags/v123
remote: post-receive< <ZERO-OID> <COMMIT-A> refs/pull/124/head
To <URL/of/upstream.git>
- [deleted] refs/pull/123/head
<OID-A>..<OID-B> <COMMIT-B> -> topic
- [deleted] v123
* [new reference] <COMMIT-A> -> refs/pull/124/head
EOF
test_cmp expect actual &&
git -C "$upstream" show-ref >out &&
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-A> refs/heads/master
<COMMIT-B> refs/heads/topic
EOF
test_cmp expect actual
'