mirror of
https://github.com/git/git
synced 2024-08-27 19:49:21 +00:00
![Patrick Steinhardt](/assets/img/avatar_default.png)
In the testcase to exercise backfilling of tags for fetches we evoke a failure of the backfilling mechanism by creating a reference that later on causes a D/F conflict. Because the assumption was that git-fetch(1) would notice the D/F conflict early on this conflicting reference was created via the reference-transaction hook just when we were about to write the backfilled tag. As it turns out though this is not the case, and the fetch fails in the same way when we create the conflicting ref up front. Simplify the test setup creating the reference up front, which allows us to get rid of the hook script. Signed-off-by: Patrick Steinhardt <ps@pks.im> Signed-off-by: Junio C Hamano <gitster@pobox.com>
228 lines
5.3 KiB
Bash
Executable file
228 lines
5.3 KiB
Bash
Executable file
#!/bin/sh
|
|
|
|
test_description='test automatic tag following'
|
|
|
|
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
|
|
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
|
|
|
|
. ./test-lib.sh
|
|
|
|
# End state of the repository:
|
|
#
|
|
# T - tag1 S - tag2
|
|
# / /
|
|
# L - A ------ O ------ B
|
|
# \ \ \
|
|
# \ C - origin/cat \
|
|
# origin/main main
|
|
|
|
test_expect_success setup '
|
|
test_tick &&
|
|
echo ichi >file &&
|
|
git add file &&
|
|
git commit -m L &&
|
|
L=$(git rev-parse --verify HEAD) &&
|
|
|
|
(
|
|
mkdir cloned &&
|
|
cd cloned &&
|
|
git init-db &&
|
|
git remote add -f origin ..
|
|
) &&
|
|
|
|
test_tick &&
|
|
echo A >file &&
|
|
git add file &&
|
|
git commit -m A &&
|
|
A=$(git rev-parse --verify HEAD)
|
|
'
|
|
|
|
U=UPLOAD_LOG
|
|
UPATH="$(pwd)/$U"
|
|
|
|
test_expect_success 'setup expect' '
|
|
cat - <<EOF >expect
|
|
want $A
|
|
EOF
|
|
'
|
|
|
|
get_needs () {
|
|
test -s "$1" &&
|
|
perl -alne '
|
|
next unless $F[1] eq "upload-pack<";
|
|
next unless $F[2] eq "want";
|
|
print $F[2], " ", $F[3];
|
|
' "$1"
|
|
}
|
|
|
|
test_expect_success 'fetch A (new commit : 1 connection)' '
|
|
rm -f $U &&
|
|
(
|
|
cd cloned &&
|
|
GIT_TRACE_PACKET=$UPATH git fetch &&
|
|
test $A = $(git rev-parse --verify origin/main)
|
|
) &&
|
|
get_needs $U >actual &&
|
|
test_cmp expect actual
|
|
'
|
|
|
|
test_expect_success "create tag T on A, create C on branch cat" '
|
|
git tag -a -m tag1 tag1 $A &&
|
|
T=$(git rev-parse --verify tag1) &&
|
|
|
|
git checkout -b cat &&
|
|
echo C >file &&
|
|
git add file &&
|
|
git commit -m C &&
|
|
C=$(git rev-parse --verify HEAD) &&
|
|
git checkout main
|
|
'
|
|
|
|
test_expect_success 'setup expect' '
|
|
cat - <<EOF >expect
|
|
want $C
|
|
want $T
|
|
EOF
|
|
'
|
|
|
|
test_expect_success 'fetch C, T (new branch, tag : 1 connection)' '
|
|
rm -f $U &&
|
|
(
|
|
cd cloned &&
|
|
GIT_TRACE_PACKET=$UPATH git fetch &&
|
|
test $C = $(git rev-parse --verify origin/cat) &&
|
|
test $T = $(git rev-parse --verify tag1) &&
|
|
test $A = $(git rev-parse --verify tag1^0)
|
|
) &&
|
|
get_needs $U >actual &&
|
|
test_cmp expect actual
|
|
'
|
|
|
|
test_expect_success "create commits O, B, tag S on B" '
|
|
test_tick &&
|
|
echo O >file &&
|
|
git add file &&
|
|
git commit -m O &&
|
|
|
|
test_tick &&
|
|
echo B >file &&
|
|
git add file &&
|
|
git commit -m B &&
|
|
B=$(git rev-parse --verify HEAD) &&
|
|
|
|
git tag -a -m tag2 tag2 $B &&
|
|
S=$(git rev-parse --verify tag2)
|
|
'
|
|
|
|
test_expect_success 'setup expect' '
|
|
cat - <<EOF >expect
|
|
want $B
|
|
want $S
|
|
EOF
|
|
'
|
|
|
|
test_expect_success 'fetch B, S (commit and tag : 1 connection)' '
|
|
rm -f $U &&
|
|
(
|
|
cd cloned &&
|
|
GIT_TRACE_PACKET=$UPATH git fetch &&
|
|
test $B = $(git rev-parse --verify origin/main) &&
|
|
test $B = $(git rev-parse --verify tag2^0) &&
|
|
test $S = $(git rev-parse --verify tag2)
|
|
) &&
|
|
get_needs $U >actual &&
|
|
test_cmp expect actual
|
|
'
|
|
|
|
test_expect_success 'setup expect' '
|
|
cat - <<EOF >expect
|
|
want $B
|
|
want $S
|
|
EOF
|
|
'
|
|
|
|
test_expect_success 'new clone fetch main and tags' '
|
|
test_might_fail git branch -D cat &&
|
|
rm -f $U &&
|
|
(
|
|
mkdir clone2 &&
|
|
cd clone2 &&
|
|
git init &&
|
|
git remote add origin .. &&
|
|
GIT_TRACE_PACKET=$UPATH git fetch &&
|
|
test $B = $(git rev-parse --verify origin/main) &&
|
|
test $S = $(git rev-parse --verify tag2) &&
|
|
test $B = $(git rev-parse --verify tag2^0) &&
|
|
test $T = $(git rev-parse --verify tag1) &&
|
|
test $A = $(git rev-parse --verify tag1^0)
|
|
) &&
|
|
get_needs $U >actual &&
|
|
test_cmp expect actual
|
|
'
|
|
|
|
test_expect_success 'atomic fetch with failing backfill' '
|
|
git init clone3 &&
|
|
|
|
# We want to test whether a failure when backfilling tags correctly
|
|
# aborts the complete transaction when `--atomic` is passed: we should
|
|
# neither create the branch nor should we create the tag when either
|
|
# one of both fails to update correctly.
|
|
#
|
|
# To trigger failure we simply abort when backfilling a tag.
|
|
write_script clone3/.git/hooks/reference-transaction <<-\EOF &&
|
|
while read oldrev newrev reference
|
|
do
|
|
if test "$reference" = refs/tags/tag1
|
|
then
|
|
exit 1
|
|
fi
|
|
done
|
|
EOF
|
|
|
|
test_must_fail git -C clone3 fetch --atomic .. $B:refs/heads/something &&
|
|
test_must_fail git -C clone3 rev-parse --verify refs/heads/something &&
|
|
test_must_fail git -C clone3 rev-parse --verify refs/tags/tag2
|
|
'
|
|
|
|
test_expect_success 'atomic fetch with backfill should use single transaction' '
|
|
git init clone4 &&
|
|
|
|
# Fetching with the `--atomic` flag should update all references in a
|
|
# single transaction, including backfilled tags. We thus expect to see
|
|
# a single reference transaction for the created branch and tags.
|
|
cat >expected <<-EOF &&
|
|
prepared
|
|
$ZERO_OID $B refs/heads/something
|
|
$ZERO_OID $S refs/tags/tag2
|
|
$ZERO_OID $T refs/tags/tag1
|
|
committed
|
|
$ZERO_OID $B refs/heads/something
|
|
$ZERO_OID $S refs/tags/tag2
|
|
$ZERO_OID $T refs/tags/tag1
|
|
EOF
|
|
|
|
write_script clone4/.git/hooks/reference-transaction <<-\EOF &&
|
|
( echo "$*" && cat ) >>actual
|
|
EOF
|
|
|
|
git -C clone4 fetch --atomic .. $B:refs/heads/something &&
|
|
test_cmp expected clone4/actual
|
|
'
|
|
|
|
test_expect_success 'backfill failure causes command to fail' '
|
|
git init clone5 &&
|
|
|
|
# Create a tag that is nested below the tag we are about to fetch via
|
|
# the backfill mechanism. This causes a D/F conflict when backfilling
|
|
# and should thus cause the command to fail.
|
|
empty_blob=$(git -C clone5 hash-object -w --stdin </dev/null) &&
|
|
git -C clone5 update-ref refs/tags/tag1/nested $empty_blob &&
|
|
|
|
test_must_fail git -C clone5 fetch .. $B:refs/heads/something &&
|
|
test $B = $(git -C clone5 rev-parse --verify refs/heads/something) &&
|
|
test $S = $(git -C clone5 rev-parse --verify tag2) &&
|
|
test_must_fail git -C clone5 rev-parse --verify tag1
|
|
'
|
|
|
|
test_done
|