kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

Merge branch 'ps/send-pack-unhide-error-in-atomic-push' 

"git push --atomic --porcelain" used to ignore failures from the
other side, losing the error status from the child process, which
has been corrected.

* ps/send-pack-unhide-error-in-atomic-push:
  send-pack: gracefully close the connection for atomic push
  t5543: atomic push reports exit code failure
  send-pack: new return code "ERROR_SEND_PACK_BAD_REF_STATUS"
  t5548: add porcelain push test cases for dry-run mode
  t5548: add new porcelain test cases
  t5548: refactor test cases by resetting upstream
  t5548: refactor to reuse setup_upstream() function
  t5504: modernize test by moving heredocs into test bodies
maint
Junio C Hamano 2025-02-18 15:30:32 -08:00
parent e565f37553 b81f8c8dd3
commit 345aaf3976
6 changed files with 411 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
send-pack.c
View File

@ -632,7 +632,8 @@ int send_pack(struct repository *r,
reject_atomic_push(remote_refs, args->send_mirror);
error("atomic push failed for ref %s. status: %d",
ref->name, ref->status);
ret = args->porcelain ? 0 : -1;
ret = ERROR_SEND_PACK_BAD_REF_STATUS;
packet_flush(out);
goto out;
}
/* else fallthrough */
@ -763,11 +764,6 @@ int send_pack(struct repository *r,
if (ret < 0)
goto out;

if (args->porcelain) {
ret = 0;
goto out;
}

for (ref = remote_refs; ref; ref = ref->next) {
switch (ref->status) {
case REF_STATUS_NONE:
@ -775,7 +771,7 @@ int send_pack(struct repository *r,
case REF_STATUS_OK:
break;
default:
ret = -1;
ret = ERROR_SEND_PACK_BAD_REF_STATUS;
goto out;
}
}

13
send-pack.h
View File

@ -13,6 +13,9 @@ struct repository;
#define SEND_PACK_PUSH_CERT_IF_ASKED 1
#define SEND_PACK_PUSH_CERT_ALWAYS 2

/* At least one reference has been rejected by the remote side. */
#define ERROR_SEND_PACK_BAD_REF_STATUS 1

struct send_pack_args {
const char *url;
unsigned verbose:1,
@ -36,6 +39,16 @@ struct option;
int option_parse_push_signed(const struct option *opt,
const char *arg, int unset);

/*
* Compute a packfile and write it to a file descriptor. The `fd` array needs
* to contain two file descriptors: `fd[0]` is the file descriptor used as
* input for the packet reader, whereas `fd[1]` is the file descriptor the
* packfile will be written to.
*
* Returns 0 on success, non-zero otherwise. Negative return values indicate a
* generic error, whereas positive return values indicate specific error
* conditions as documented with the `ERROR_SEND_PACK_*` constants.
*/
int send_pack(struct repository *r, struct send_pack_args *args,
int fd[], struct child_process *conn,
struct ref *remote_refs, struct oid_array *extra_have);

35
t/t5504-fetch-receive-strict.sh
View File

@ -64,12 +64,6 @@ test_expect_success 'fetch with transfer.fsckobjects' '
)
'

cat >exp <<EOF
To dst
! refs/heads/main:refs/heads/test [remote rejected] (missing necessary objects)
Done
EOF

test_expect_success 'push without strict' '
rm -rf dst &&
git init dst &&
@ -78,6 +72,11 @@ test_expect_success 'push without strict' '
git config fetch.fsckobjects false &&
git config transfer.fsckobjects false
) &&
cat >exp <<-\EOF &&
To dst
! refs/heads/main:refs/heads/test [remote rejected] (missing necessary objects)
Done
EOF
test_must_fail git push --porcelain dst main:refs/heads/test >act &&
test_cmp exp act
'
@ -94,11 +93,6 @@ test_expect_success 'push with !receive.fsckobjects' '
test_cmp exp act
'

cat >exp <<EOF
To dst
! refs/heads/main:refs/heads/test [remote rejected] (unpacker error)
EOF

test_expect_success 'push with receive.fsckobjects' '
rm -rf dst &&
git init dst &&
@ -107,6 +101,10 @@ test_expect_success 'push with receive.fsckobjects' '
git config receive.fsckobjects true &&
git config transfer.fsckobjects false
) &&
cat >exp <<-\EOF &&
To dst
! refs/heads/main:refs/heads/test [remote rejected] (unpacker error)
EOF
test_must_fail git push --porcelain dst main:refs/heads/test >act &&
test_cmp exp act
'
@ -129,15 +127,14 @@ test_expect_success 'repair the "corrupt or missing" object' '
git fsck
'

cat >bogus-commit <<EOF
tree $EMPTY_TREE
author Bugs Bunny 1234567890 +0000
committer Bugs Bunny <bugs@bun.ni> 1234567890 +0000

This commit object intentionally broken
EOF

test_expect_success 'setup bogus commit' '
cat >bogus-commit <<-EOF &&
tree $EMPTY_TREE
author Bugs Bunny 1234567890 +0000
committer Bugs Bunny <bugs@bun.ni> 1234567890 +0000

This commit object intentionally broken
EOF
commit="$(git hash-object --literally -t commit -w --stdin <bogus-commit)"
'


30
t/t5543-atomic-push.sh
View File

@ -280,4 +280,34 @@ test_expect_success 'atomic push reports (reject by non-ff)' '
test_cmp expect actual
'

test_expect_success 'atomic push reports exit code failure' '
write_script receive-pack-wrapper <<-\EOF &&
git-receive-pack "$@"
exit 1
EOF
test_must_fail git -C workbench push --atomic \
--receive-pack="${SQ}$(pwd)${SQ}/receive-pack-wrapper" \
up HEAD:refs/heads/no-conflict 2>err &&
cat >expect <<-EOF &&
To ../upstream
* [new branch] HEAD -> no-conflict
error: failed to push some refs to ${SQ}../upstream${SQ}
EOF
test_cmp expect err
'

test_expect_success 'atomic push reports exit code failure with porcelain' '
write_script receive-pack-wrapper <<-\EOF &&
git-receive-pack "$@"
exit 1
EOF
test_must_fail git -C workbench push --atomic --porcelain \
--receive-pack="${SQ}$(pwd)${SQ}/receive-pack-wrapper" \
up HEAD:refs/heads/no-conflict-porcelain 2>err &&
cat >expect <<-EOF &&
error: failed to push some refs to ${SQ}../upstream${SQ}
EOF
test_cmp expect err
'

test_done

453
t/t5548-push-porcelain.sh
View File

@ -54,29 +54,67 @@ format_and_save_expect () {
sed -e 's/^> //' -e 's/Z$//' >expect
}

create_upstream_template () {
git init --bare upstream-template.git &&
git clone upstream-template.git tmp_work_dir &&
create_commits_in tmp_work_dir A B &&
(
cd tmp_work_dir &&
git push origin \
$B:refs/heads/main \
$A:refs/heads/foo \
$A:refs/heads/bar \
$A:refs/heads/baz
) &&
rm -rf tmp_work_dir
}

setup_upstream () {
if test $# -ne 1
then
BUG "location of upstream repository is not provided"
fi &&
rm -rf "$1" &&
if ! test -d upstream-template.git
then
create_upstream_template
fi &&
git clone --mirror upstream-template.git "$1" &&
# The upstream repository provides services using the HTTP protocol.
if ! test "$1" = "upstream.git"
then
git -C "$1" config http.receivepack true
fi
}

setup_upstream_and_workbench () {
# Upstream after setup : main(B) foo(A) bar(A) baz(A)
# Workbench after setup : main(A)
if test $# -ne 1
then
BUG "location of upstream repository is not provided"
fi
upstream="$1"

# Upstream after setup: main(B) foo(A) bar(A) baz(A)
# Workbench after setup: main(A) baz(A) next(A)
test_expect_success "setup upstream repository and workbench" '
rm -rf upstream.git workbench &&
git init --bare upstream.git &&
git init workbench &&
create_commits_in workbench A B &&
setup_upstream "$upstream" &&
rm -rf workbench &&
git clone "$upstream" workbench &&
(
cd workbench &&
git update-ref refs/heads/main $A &&
git update-ref refs/heads/baz $A &&
git update-ref refs/heads/next $A &&
# Try to make a stable fixed width for abbreviated commit ID,
# this fixed-width oid will be replaced with "<OID>".
git config core.abbrev 7 &&
git remote add origin ../upstream.git &&
git update-ref refs/heads/main $A &&
git push origin \
$B:refs/heads/main \
$A:refs/heads/foo \
$A:refs/heads/bar \
$A:refs/heads/baz
git config advice.pushUpdateRejected false
) &&
git -C "workbench" config advice.pushUpdateRejected false &&
upstream=upstream.git
# The upstream repository provides services using the HTTP protocol.
if ! test "$upstream" = "upstream.git"
then
git -C workbench remote set-url origin "$HTTPD_URL/smart/upstream.git"
fi
'
}

@ -88,26 +126,55 @@ run_git_push_porcelain_output_test() {
;;
file)
PROTOCOL="builtin protocol"
URL_PREFIX="\.\."
URL_PREFIX=".*"
;;
esac

# Refs of upstream : main(B) foo(A) bar(A) baz(A)
# Refs of workbench: main(A) baz(A) next(A)
# git-push : main(A) NULL (B) baz(A) next(A)
test_expect_success "porcelain output of successful git-push ($PROTOCOL)" '
(
cd workbench &&
git update-ref refs/heads/main $A &&
git update-ref refs/heads/baz $A &&
git update-ref refs/heads/next $A &&
git push --porcelain --force origin \
main \
:refs/heads/foo \
$B:bar \
baz \
next
) >out &&
test_expect_success ".. git-push --porcelain ($PROTOCOL)" '
test_when_finished "setup_upstream \"$upstream\"" &&
test_must_fail git -C workbench push --porcelain origin \
main \
:refs/heads/foo \
$B:bar \
baz \
next >out &&
make_user_friendly_and_stable_output <out >actual &&
format_and_save_expect <<-\EOF &&
> To <URL/of/upstream.git>
> = refs/heads/baz:refs/heads/baz [up to date]
> <COMMIT-B>:refs/heads/bar <COMMIT-A>..<COMMIT-B>
> - :refs/heads/foo [deleted]
> * refs/heads/next:refs/heads/next [new branch]
> ! refs/heads/main:refs/heads/main [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/bar
<COMMIT-A> refs/heads/baz
<COMMIT-B> refs/heads/main
<COMMIT-A> refs/heads/next
EOF
test_cmp expect actual
'

# Refs of upstream : main(B) foo(A) bar(A) baz(A)
# Refs of workbench: main(A) baz(A) next(A)
# git-push : main(A) NULL (B) baz(A) next(A)
test_expect_success ".. git-push --porcelain --force ($PROTOCOL)" '
test_when_finished "setup_upstream \"$upstream\"" &&
git -C workbench push --porcelain --force origin \
main \
:refs/heads/foo \
$B:bar \
baz \
next >out &&
make_user_friendly_and_stable_output <out >actual &&
format_and_save_expect <<-EOF &&
> To <URL/of/upstream.git>
@ -131,108 +198,129 @@ run_git_push_porcelain_output_test() {
test_cmp expect actual
'

# Refs of upstream : main(A) bar(B) baz(A) next(A)
# Refs of workbench: main(B) bar(A) baz(A) next(A)
# git-push : main(B) bar(A) NULL next(A)
test_expect_success "atomic push failed ($PROTOCOL)" '
(
cd workbench &&
git update-ref refs/heads/main $B &&
git update-ref refs/heads/bar $A &&
test_must_fail git push --atomic --porcelain origin \
main \
bar \
:baz \
next
) >out &&
# Refs of upstream : main(B) foo(A) bar(A) baz(A)
# Refs of workbench: main(A) baz(A) next(A)
# git-push : main(A) NULL (B) baz(A) next(A)
test_expect_success ".. git push --porcelain --atomic ($PROTOCOL)" '
test_when_finished "setup_upstream \"$upstream\"" &&
test_must_fail git -C workbench push --porcelain --atomic origin \
main \
:refs/heads/foo \
$B:bar \
baz \
next >out &&
make_user_friendly_and_stable_output <out >actual &&
format_and_save_expect <<-EOF &&
To <URL/of/upstream.git>
> = refs/heads/next:refs/heads/next [up to date]
> ! refs/heads/bar:refs/heads/bar [rejected] (non-fast-forward)
> ! (delete):refs/heads/baz [rejected] (atomic push failed)
> ! refs/heads/main:refs/heads/main [rejected] (atomic push failed)
Done
> To <URL/of/upstream.git>
> = refs/heads/baz:refs/heads/baz [up to date]
> ! <COMMIT-B>:refs/heads/bar [rejected] (atomic push failed)
> ! (delete):refs/heads/foo [rejected] (atomic push failed)
> ! refs/heads/main:refs/heads/main [rejected] (non-fast-forward)
> ! refs/heads/next:refs/heads/next [rejected] (atomic push 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-B> refs/heads/bar
<COMMIT-A> refs/heads/bar
<COMMIT-A> refs/heads/baz
<COMMIT-A> refs/heads/main
<COMMIT-A> refs/heads/next
<COMMIT-A> refs/heads/foo
<COMMIT-B> refs/heads/main
EOF
test_cmp expect actual
'

test_expect_success "prepare pre-receive hook ($PROTOCOL)" '
test_hook --setup -C "$upstream" pre-receive <<-EOF
exit 1
# Refs of upstream : main(B) foo(A) bar(A) baz(A)
# Refs of workbench: main(A) baz(A) next(A)
# git-push : main(A) NULL (B) baz(A) next(A)
test_expect_success ".. pre-receive hook declined ($PROTOCOL)" '
test_when_finished "rm -f \"$upstream/hooks/pre-receive\" &&
setup_upstream \"$upstream\"" &&
test_hook --setup -C "$upstream" pre-receive <<-EOF &&
exit 1
EOF
'

# Refs of upstream : main(A) bar(B) baz(A) next(A)
# Refs of workbench: main(B) bar(A) baz(A) next(A)
# git-push : main(B) bar(A) NULL next(A)
test_expect_success "pre-receive hook declined ($PROTOCOL)" '
(
cd workbench &&
git update-ref refs/heads/main $B &&
git update-ref refs/heads/bar $A &&
test_must_fail git push --porcelain --force origin \
main \
bar \
:baz \
next
) >out &&
test_must_fail git -C workbench push --porcelain --force origin \
main \
:refs/heads/foo \
$B:bar \
baz \
next >out &&
make_user_friendly_and_stable_output <out >actual &&
format_and_save_expect <<-EOF &&
To <URL/of/upstream.git>
> = refs/heads/next:refs/heads/next [up to date]
> ! refs/heads/bar:refs/heads/bar [remote rejected] (pre-receive hook declined)
> ! :refs/heads/baz [remote rejected] (pre-receive hook declined)
> To <URL/of/upstream.git>
> = refs/heads/baz:refs/heads/baz [up to date]
> ! <COMMIT-B>:refs/heads/bar [remote rejected] (pre-receive hook declined)
> ! :refs/heads/foo [remote rejected] (pre-receive hook declined)
> ! refs/heads/main:refs/heads/main [remote rejected] (pre-receive hook declined)
Done
> ! refs/heads/next: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-B> refs/heads/bar
<COMMIT-A> refs/heads/bar
<COMMIT-A> refs/heads/baz
<COMMIT-A> refs/heads/main
<COMMIT-A> refs/heads/next
<COMMIT-A> refs/heads/foo
<COMMIT-B> refs/heads/main
EOF
test_cmp expect actual
'

test_expect_success "remove pre-receive hook ($PROTOCOL)" '
rm "$upstream/hooks/pre-receive"
'

# Refs of upstream : main(A) bar(B) baz(A) next(A)
# Refs of workbench: main(B) bar(A) baz(A) next(A)
# git-push : main(B) bar(A) NULL next(A)
test_expect_success "non-fastforward push ($PROTOCOL)" '
# Refs of upstream : main(B) foo(A) bar(A) baz(A)
# Refs of workbench: main(A) baz(A) next(A)
# git-push : main(A) next(A)
test_expect_success ".. non-fastforward push ($PROTOCOL)" '
test_when_finished "setup_upstream \"$upstream\"" &&
(
cd workbench &&
test_must_fail git push --porcelain origin \
main \
bar \
:baz \
next
) >out &&
make_user_friendly_and_stable_output <out >actual &&
format_and_save_expect <<-EOF &&
To <URL/of/upstream.git>
> = refs/heads/next:refs/heads/next [up to date]
> - :refs/heads/baz [deleted]
> refs/heads/main:refs/heads/main <COMMIT-A>..<COMMIT-B>
> ! refs/heads/bar:refs/heads/bar [rejected] (non-fast-forward)
Done
> To <URL/of/upstream.git>
> * refs/heads/next:refs/heads/next [new branch]
> ! refs/heads/main:refs/heads/main [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-A> refs/heads/bar
<COMMIT-A> refs/heads/baz
<COMMIT-A> refs/heads/foo
<COMMIT-B> refs/heads/main
<COMMIT-A> refs/heads/next
EOF
test_cmp expect actual
'

# Refs of upstream : main(B) foo(A) bar(A) baz(A)
# Refs of workbench: main(A) baz(A) next(A)
# git-push : main(A) NULL (B) baz(A) next(A)
test_expect_success ".. git push --porcelain --atomic --force ($PROTOCOL)" '
git -C workbench push --porcelain --atomic --force origin \
main \
:refs/heads/foo \
$B:bar \
baz \
next >out &&
make_user_friendly_and_stable_output <out >actual &&
format_and_save_expect <<-\EOF &&
> To <URL/of/upstream.git>
> = refs/heads/baz:refs/heads/baz [up to date]
> <COMMIT-B>:refs/heads/bar <COMMIT-A>..<COMMIT-B>
> - :refs/heads/foo [deleted]
> + refs/heads/main:refs/heads/main <COMMIT-B>...<COMMIT-A> (forced update)
> * refs/heads/next:refs/heads/next [new branch]
> Done
EOF
test_cmp expect actual &&

@ -240,39 +328,180 @@ run_git_push_porcelain_output_test() {
make_user_friendly_and_stable_output <out >actual &&
cat >expect <<-EOF &&
<COMMIT-B> refs/heads/bar
<COMMIT-B> refs/heads/main
<COMMIT-A> refs/heads/baz
<COMMIT-A> refs/heads/main
<COMMIT-A> refs/heads/next
EOF
test_cmp expect actual
'
}

# Initialize the upstream repository and local workbench.
setup_upstream_and_workbench
run_git_push_dry_run_porcelain_output_test() {
case $1 in
http)
PROTOCOL="HTTP protocol"
URL_PREFIX="http://.*"
;;
file)
PROTOCOL="builtin protocol"
URL_PREFIX=".*"
;;
esac

# Refs of upstream : main(B) foo(A) bar(A) baz(A)
# Refs of workbench: main(A) baz(A) next(A)
# git-push : main(A) NULL (B) baz(A) next(A)
test_expect_success ".. git-push --porcelain --dry-run ($PROTOCOL)" '
test_must_fail git -C workbench push --porcelain --dry-run origin \
main \
:refs/heads/foo \
$B:bar \
baz \
next >out &&
make_user_friendly_and_stable_output <out >actual &&
format_and_save_expect <<-EOF &&
> To <URL/of/upstream.git>
> = refs/heads/baz:refs/heads/baz [up to date]
> <COMMIT-B>:refs/heads/bar <COMMIT-A>..<COMMIT-B>
> - :refs/heads/foo [deleted]
> * refs/heads/next:refs/heads/next [new branch]
> ! refs/heads/main:refs/heads/main [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-A> refs/heads/bar
<COMMIT-A> refs/heads/baz
<COMMIT-A> refs/heads/foo
<COMMIT-B> refs/heads/main
EOF
test_cmp expect actual
'

# Refs of upstream : main(B) foo(A) bar(A) baz(A)
# Refs of workbench: main(A) baz(A) next(A)
# push : main(A) NULL (B) baz(A) next(A)
test_expect_success ".. git-push --porcelain --dry-run --force ($PROTOCOL)" '
git -C workbench push --porcelain --dry-run --force origin \
main \
:refs/heads/foo \
$B:bar \
baz \
next >out &&
make_user_friendly_and_stable_output <out >actual &&
format_and_save_expect <<-EOF &&
> To <URL/of/upstream.git>
> = refs/heads/baz:refs/heads/baz [up to date]
> <COMMIT-B>:refs/heads/bar <COMMIT-A>..<COMMIT-B>
> - :refs/heads/foo [deleted]
> + refs/heads/main:refs/heads/main <COMMIT-B>...<COMMIT-A> (forced update)
> * refs/heads/next: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-A> refs/heads/bar
<COMMIT-A> refs/heads/baz
<COMMIT-A> refs/heads/foo
<COMMIT-B> refs/heads/main
EOF
test_cmp expect actual
'

# Refs of upstream : main(B) foo(A) bar(A) baz(A)
# Refs of workbench: main(A) baz(A) next(A)
# git-push : main(A) NULL (B) baz(A) next(A)
test_expect_success ".. git-push --porcelain --dry-run --atomic ($PROTOCOL)" '
test_must_fail git -C workbench push --porcelain --dry-run --atomic origin \
main \
:refs/heads/foo \
$B:bar \
baz \
next >out &&
make_user_friendly_and_stable_output <out >actual &&
format_and_save_expect <<-EOF &&
> To <URL/of/upstream.git>
> = refs/heads/baz:refs/heads/baz [up to date]
> ! <COMMIT-B>:refs/heads/bar [rejected] (atomic push failed)
> ! (delete):refs/heads/foo [rejected] (atomic push failed)
> ! refs/heads/main:refs/heads/main [rejected] (non-fast-forward)
> ! refs/heads/next:refs/heads/next [rejected] (atomic push 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/bar
<COMMIT-A> refs/heads/baz
<COMMIT-A> refs/heads/foo
<COMMIT-B> refs/heads/main
EOF
test_cmp expect actual
'

# Refs of upstream : main(B) foo(A) bar(A) baz(A)
# Refs of workbench: main(A) baz(A) next(A)
# push : main(A) NULL (B) baz(A) next(A)
test_expect_success ".. git-push --porcelain --dry-run --atomic --force ($PROTOCOL)" '
git -C workbench push --porcelain --dry-run --atomic --force origin \
main \
:refs/heads/foo \
$B:bar \
baz \
next >out &&
make_user_friendly_and_stable_output <out >actual &&
format_and_save_expect <<-EOF &&
> To <URL/of/upstream.git>
> = refs/heads/baz:refs/heads/baz [up to date]
> <COMMIT-B>:refs/heads/bar <COMMIT-A>..<COMMIT-B>
> - :refs/heads/foo [deleted]
> + refs/heads/main:refs/heads/main <COMMIT-B>...<COMMIT-A> (forced update)
> * refs/heads/next: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-A> refs/heads/bar
<COMMIT-A> refs/heads/baz
<COMMIT-A> refs/heads/foo
<COMMIT-B> refs/heads/main
EOF
test_cmp expect actual
'
}

setup_upstream_and_workbench upstream.git

# Run git-push porcelain test on builtin protocol
run_git_push_porcelain_output_test file

setup_upstream_and_workbench upstream.git

run_git_push_dry_run_porcelain_output_test file

ROOT_PATH="$PWD"
. "$TEST_DIRECTORY"/lib-gpg.sh
. "$TEST_DIRECTORY"/lib-httpd.sh
. "$TEST_DIRECTORY"/lib-terminal.sh
start_httpd

# Re-initialize the upstream repository and local workbench.
setup_upstream_and_workbench

test_expect_success "setup for http" '
git -C upstream.git config http.receivepack true &&
upstream="$HTTPD_DOCUMENT_ROOT_PATH/upstream.git" &&
mv upstream.git "$upstream" &&

git -C workbench remote set-url origin $HTTPD_URL/smart/upstream.git
'

setup_askpass_helper

# Run git-push porcelain test on HTTP protocol
setup_upstream_and_workbench "$HTTPD_DOCUMENT_ROOT_PATH/upstream.git"

run_git_push_porcelain_output_test http

setup_upstream_and_workbench "$HTTPD_DOCUMENT_ROOT_PATH/upstream.git"

run_git_push_dry_run_porcelain_output_test http

test_done

17
transport.c
View File

@ -935,6 +935,13 @@ static int git_transport_push(struct transport *transport, struct ref *remote_re
case protocol_v0:
ret = send_pack(the_repository, &args, data->fd, data->conn, remote_refs,
&data->extra_have);
/*
* Ignore the specific error code to maintain consistent behavior
* with the "push_refs()" function across different transports,
* such as "push_refs_with_push()" for HTTP protocol.
*/
if (ret == ERROR_SEND_PACK_BAD_REF_STATUS)
ret = 0;
break;
case protocol_unknown_version:
BUG("unknown protocol version");
@ -942,15 +949,7 @@ static int git_transport_push(struct transport *transport, struct ref *remote_re

close(data->fd[1]);
close(data->fd[0]);
/*
* Atomic push may abort the connection early and close the pipe,
* which may cause an error for `finish_connect()`. Ignore this error
* for atomic git-push.
*/
if (ret || args.atomic)
finish_connect(data->conn);
else
ret = finish_connect(data->conn);
ret |= finish_connect(data->conn);
data->conn = NULL;
data->finished_handshake = 0;