git-for-windows/git
1
0
Fork 0
mirror of https://github.com/git-for-windows/git.git synced 2026-05-31 12:28:51 -05:00
Code Issues Packages Projects Releases 335 Wiki Activity
Files
b05eb5c0594c55b8c94de30be269e897ffd5ac93
git/t/t6020-bundle-misc.sh
Derrick Stolee 8da7363275 pack-objects: add GIT_TEST_FULL_NAME_HASH 
Add a new environment variable to opt-in to the --full-name-hash option
in 'git pack-objects'. This allows for extra testing of the feature
without repeating all of the test scenarios.

But this option isn't free. There are a few tests that change behavior
with the variable enabled.

First, there are a few tests that are very sensitive to certain delta
bases being picked. These are both involving the generation of thin
bundles and then counting their objects via 'git index-pack --fix-thin'
which pulls the delta base into the new packfile. For these tests,
disable the option as a decent long-term option.

Second, there are two tests in t5616-partial-clone.sh that I believe are
actually broken scenarios. While the client is set up to clone the
'promisor-server' repo via a treeless partial clone filter (tree:0),
that filter does not translate to the 'server' repo. Thus, fetching from
these repos causes the server to think that the client has all reachable
trees and blobs from the commits advertised as 'haves'. This leads the
server to providing a thin pack assuming those objects as delta bases.
Changing the name-hash algorithm presents new delta bases and thus
breaks the expectations of these tests. An alternative could be to set
up 'server' as a promisor server with the correct filter enabled. This
may also point out more issues with partial clone being set up as a
remote-based filtering mechanism and not a repository-wide setting. For
now, do the minimal change to make the test work by disabling the test
variable.

Signed-off-by: Derrick Stolee <stolee@gmail.com>
2025-01-11 17:19:36 +01:00

735 lines
19 KiB
Bash
Executable File
Raw Blame History

#!/bin/sh
#
# Copyright (c) 2021 Jiang Xin
#
test_description='Test git-bundle'
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
. ./test-lib.sh
. "$TEST_DIRECTORY"/lib-bundle.sh
. "$TEST_DIRECTORY"/lib-terminal.sh
for cmd in create verify list-heads unbundle
do
test_expect_success "usage: git bundle $cmd needs an argument" '
test_expect_code 129 git bundle $cmd
'
done
# Create a commit or tag and set the variable with the object ID.
test_commit_setvar () {
notick=
signoff=
indir=
merge=
tag=
var=
while test $# != 0
do
case "$1" in
--merge)
merge=t
;;
--tag)
tag=t
;;
--notick)
notick=t
;;
--signoff)
signoff="$1"
;;
-C)
shift
indir="$1"
;;
-*)
echo >&2 "error: unknown option $1"
return 1
;;
*)
break
;;
esac
shift
done
if test $# -lt 2
then
echo >&2 "error: test_commit_setvar must have at least 2 arguments"
return 1
fi
var=$1
shift
indir=${indir:+"$indir"/}
if test -z "$notick"
then
test_tick
fi &&
if test -n "$merge"
then
git ${indir:+ -C "$indir"} merge --no-edit --no-ff \
${2:+-m "$2"} "$1" &&
oid=$(git ${indir:+ -C "$indir"} rev-parse HEAD)
elif test -n "$tag"
then
git ${indir:+ -C "$indir"} tag -m "$1" "$1" "${2:-HEAD}" &&
oid=$(git ${indir:+ -C "$indir"} rev-parse "$1")
else
file=${2:-"$1.t"} &&
echo "${3-$1}" >"$indir$file" &&
git ${indir:+ -C "$indir"} add "$file" &&
git ${indir:+ -C "$indir"} commit $signoff -m "$1" &&
oid=$(git ${indir:+ -C "$indir"} rev-parse HEAD)
fi &&
eval $var=$oid
}
get_abbrev_oid () {
oid=$1 &&
suffix=${oid#???????} &&
oid=${oid%$suffix} &&
if test -n "$oid"
then
echo "$oid"
else
echo "undefined-oid"
fi
}
# Format the output of git 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.
make_user_friendly_and_stable_output () {
sed \
-e "s/$(get_abbrev_oid $A)[0-9a-f]*/<COMMIT-A>/g" \
-e "s/$(get_abbrev_oid $B)[0-9a-f]*/<COMMIT-B>/g" \
-e "s/$(get_abbrev_oid $C)[0-9a-f]*/<COMMIT-C>/g" \
-e "s/$(get_abbrev_oid $D)[0-9a-f]*/<COMMIT-D>/g" \
-e "s/$(get_abbrev_oid $E)[0-9a-f]*/<COMMIT-E>/g" \
-e "s/$(get_abbrev_oid $F)[0-9a-f]*/<COMMIT-F>/g" \
-e "s/$(get_abbrev_oid $G)[0-9a-f]*/<COMMIT-G>/g" \
-e "s/$(get_abbrev_oid $H)[0-9a-f]*/<COMMIT-H>/g" \
-e "s/$(get_abbrev_oid $I)[0-9a-f]*/<COMMIT-I>/g" \
-e "s/$(get_abbrev_oid $J)[0-9a-f]*/<COMMIT-J>/g" \
-e "s/$(get_abbrev_oid $K)[0-9a-f]*/<COMMIT-K>/g" \
-e "s/$(get_abbrev_oid $L)[0-9a-f]*/<COMMIT-L>/g" \
-e "s/$(get_abbrev_oid $M)[0-9a-f]*/<COMMIT-M>/g" \
-e "s/$(get_abbrev_oid $N)[0-9a-f]*/<COMMIT-N>/g" \
-e "s/$(get_abbrev_oid $O)[0-9a-f]*/<COMMIT-O>/g" \
-e "s/$(get_abbrev_oid $P)[0-9a-f]*/<COMMIT-P>/g" \
-e "s/$(get_abbrev_oid $TAG1)[0-9a-f]*/<TAG-1>/g" \
-e "s/$(get_abbrev_oid $TAG2)[0-9a-f]*/<TAG-2>/g" \
-e "s/$(get_abbrev_oid $TAG3)[0-9a-f]*/<TAG-3>/g"
}
format_and_save_expect () {
sed -e 's/Z$//' >expect
}
HASH_MESSAGE="The bundle uses this hash algorithm: $GIT_DEFAULT_HASH"
# (C) (D, pull/1/head, topic/1)
# o --- o
# / \ (L)
# / \ o (H, topic/2) (M, tag:v2)
# / (F) \ / (N, tag:v3)
# / o --------- o (G, pull/2/head) o --- o --- o (release)
# / / \ \ / \
# o --- o --- o -------- o -- o ------------------ o ------- o --- o (main)
# (A) (B) (E, tag:v1) (I) (J) (K) (O) (P)
#
test_expect_success 'setup' '
# 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 &&
# branch main: commit A & B
test_commit_setvar A "Commit A" main.txt &&
test_commit_setvar B "Commit B" main.txt &&
# branch topic/1: commit C & D, refs/pull/1/head
git checkout -b topic/1 &&
test_commit_setvar C "Commit C" topic-1.txt &&
test_commit_setvar D "Commit D" topic-1.txt &&
git update-ref refs/pull/1/head HEAD &&
# branch topic/1: commit E, tag v1
git checkout main &&
test_commit_setvar E "Commit E" main.txt &&
test_commit_setvar --tag TAG1 v1 &&
# branch topic/2: commit F & G, refs/pull/2/head
git checkout -b topic/2 &&
test_commit_setvar F "Commit F" topic-2.txt &&
test_commit_setvar G "Commit G" topic-2.txt &&
git update-ref refs/pull/2/head HEAD &&
test_commit_setvar H "Commit H" topic-2.txt &&
# branch main: merge commit I & J
git checkout main &&
test_commit_setvar --merge I topic/1 "Merge commit I" &&
test_commit_setvar --merge J refs/pull/2/head "Merge commit J" &&
# branch main: commit K
git checkout main &&
test_commit_setvar K "Commit K" main.txt &&
# branch release:
git checkout -b release &&
test_commit_setvar L "Commit L" release.txt &&
test_commit_setvar M "Commit M" release.txt &&
test_commit_setvar --tag TAG2 v2 &&
test_commit_setvar N "Commit N" release.txt &&
test_commit_setvar --tag TAG3 v3 &&
# branch main: merge commit O, commit P
git checkout main &&
test_commit_setvar --merge O tags/v2 "Merge commit O" &&
test_commit_setvar P "Commit P" main.txt
'
test_expect_success 'create bundle from special rev: main^!' '
git bundle create special-rev.bdl "main^!" &&
git bundle list-heads special-rev.bdl |
make_user_friendly_and_stable_output >actual &&
cat >expect <<-\EOF &&
<COMMIT-P> refs/heads/main
EOF
test_cmp expect actual &&
git bundle verify special-rev.bdl |
make_user_friendly_and_stable_output >actual &&
format_and_save_expect <<-EOF &&
The bundle contains this ref:
<COMMIT-P> refs/heads/main
The bundle requires this ref:
<COMMIT-O> Z
$HASH_MESSAGE
EOF
test_cmp expect actual &&
test_bundle_object_count special-rev.bdl 3
'
test_expect_success 'create bundle with --max-count option' '
git bundle create max-count.bdl --max-count 1 \
main \
"^release" \
refs/tags/v1 \
refs/pull/1/head \
refs/pull/2/head &&
git bundle verify max-count.bdl |
make_user_friendly_and_stable_output >actual &&
format_and_save_expect <<-EOF &&
The bundle contains these 2 refs:
<COMMIT-P> refs/heads/main
<TAG-1> refs/tags/v1
The bundle requires this ref:
<COMMIT-O> Z
$HASH_MESSAGE
EOF
test_cmp expect actual &&
test_bundle_object_count max-count.bdl 4
'
test_expect_success 'create bundle with --since option' '
git log -1 --pretty="%ad" $M >actual &&
cat >expect <<-\EOF &&
Thu Apr 7 15:26:13 2005 -0700
EOF
test_cmp expect actual &&
# If the --full-name-hash option is used, then one fewer
# delta base is found and this counts a different number
# of objects after performing --fix-thin.
GIT_TEST_FULL_NAME_HASH=0 \
git bundle create since.bdl \
--since "Thu Apr 7 15:27:00 2005 -0700" \
--all &&
git bundle verify since.bdl |
make_user_friendly_and_stable_output >actual &&
format_and_save_expect <<-EOF &&
The bundle contains these 5 refs:
<COMMIT-P> refs/heads/main
<COMMIT-N> refs/heads/release
<TAG-2> refs/tags/v2
<TAG-3> refs/tags/v3
<COMMIT-P> HEAD
The bundle requires these 2 refs:
<COMMIT-M> Z
<COMMIT-K> Z
$HASH_MESSAGE
EOF
test_cmp expect actual &&
test_bundle_object_count --thin since.bdl 13
'
test_expect_success 'create bundle 1 - no prerequisites' '
# create bundle from args
git bundle create 1.bdl topic/1 topic/2 &&
# create bundle from stdin
cat >input <<-\EOF &&
topic/1
topic/2
EOF
git bundle create stdin-1.bdl --stdin <input &&
format_and_save_expect <<-EOF &&
The bundle contains these 2 refs:
<COMMIT-D> refs/heads/topic/1
<COMMIT-H> refs/heads/topic/2
The bundle records a complete history.
$HASH_MESSAGE
EOF
# verify bundle, which has no prerequisites
git bundle verify 1.bdl |
make_user_friendly_and_stable_output >actual &&
test_cmp expect actual &&
git bundle verify stdin-1.bdl |
make_user_friendly_and_stable_output >actual &&
test_cmp expect actual &&
test_bundle_object_count 1.bdl 24 &&
test_bundle_object_count stdin-1.bdl 24
'
test_expect_success 'create bundle 2 - has prerequisites' '
# create bundle from args
git bundle create 2.bdl \
--ignore-missing \
^topic/deleted \
^$D \
^topic/2 \
release &&
# create bundle from stdin
# input has a non-exist reference: "topic/deleted"
cat >input <<-EOF &&
^topic/deleted
^$D
^topic/2
EOF
git bundle create stdin-2.bdl \
--ignore-missing \
--stdin \
release <input &&
format_and_save_expect <<-EOF &&
The bundle contains this ref:
<COMMIT-N> refs/heads/release
The bundle requires these 3 refs:
<COMMIT-D> Z
<COMMIT-E> Z
<COMMIT-G> Z
$HASH_MESSAGE
EOF
git bundle verify 2.bdl |
make_user_friendly_and_stable_output >actual &&
test_cmp expect actual &&
git bundle verify stdin-2.bdl |
make_user_friendly_and_stable_output >actual &&
test_cmp expect actual &&
test_bundle_object_count 2.bdl 16 &&
test_bundle_object_count stdin-2.bdl 16
'
test_expect_success 'fail to verify bundle without prerequisites' '
git init --bare test1.git &&
format_and_save_expect <<-\EOF &&
error: Repository lacks these prerequisite commits:
error: <COMMIT-D> Z
error: <COMMIT-E> Z
error: <COMMIT-G> Z
EOF
test_must_fail git -C test1.git bundle verify ../2.bdl 2>&1 |
make_user_friendly_and_stable_output >actual &&
test_cmp expect actual &&
test_must_fail git -C test1.git bundle verify ../stdin-2.bdl 2>&1 |
make_user_friendly_and_stable_output >actual &&
test_cmp expect actual
'
test_expect_success 'create bundle 3 - two refs, same object' '
# create bundle from args
git bundle create --version=3 3.bdl \
^release \
^topic/1 \
^topic/2 \
main \
HEAD &&
# create bundle from stdin
cat >input <<-\EOF &&
^release
^topic/1
^topic/2
EOF
git bundle create --version=3 stdin-3.bdl \
--stdin \
main HEAD <input &&
format_and_save_expect <<-EOF &&
The bundle contains these 2 refs:
<COMMIT-P> refs/heads/main
<COMMIT-P> HEAD
The bundle requires these 2 refs:
<COMMIT-M> Z
<COMMIT-K> Z
$HASH_MESSAGE
EOF
git bundle verify 3.bdl |
make_user_friendly_and_stable_output >actual &&
test_cmp expect actual &&
git bundle verify stdin-3.bdl |
make_user_friendly_and_stable_output >actual &&
test_cmp expect actual &&
test_bundle_object_count 3.bdl 4 &&
test_bundle_object_count stdin-3.bdl 4
'
test_expect_success 'create bundle 4 - with tags' '
# create bundle from args
git bundle create 4.bdl \
^main \
^release \
^topic/1 \
^topic/2 \
--all &&
# create bundle from stdin
cat >input <<-\EOF &&
^main
^release
^topic/1
^topic/2
EOF
git bundle create stdin-4.bdl \
--ignore-missing \
--stdin \
--all <input &&
cat >expect <<-EOF &&
The bundle contains these 3 refs:
<TAG-1> refs/tags/v1
<TAG-2> refs/tags/v2
<TAG-3> refs/tags/v3
The bundle records a complete history.
$HASH_MESSAGE
EOF
git bundle verify 4.bdl |
make_user_friendly_and_stable_output >actual &&
test_cmp expect actual &&
git bundle verify stdin-4.bdl |
make_user_friendly_and_stable_output >actual &&
test_cmp expect actual &&
test_bundle_object_count 4.bdl 3 &&
test_bundle_object_count stdin-4.bdl 3
'
test_expect_success 'clone from bundle' '
git clone --mirror 1.bdl mirror.git &&
git -C mirror.git show-ref |
make_user_friendly_and_stable_output >actual &&
cat >expect <<-\EOF &&
<COMMIT-D> refs/heads/topic/1
<COMMIT-H> refs/heads/topic/2
EOF
test_cmp expect actual &&
git -C mirror.git fetch ../2.bdl "+refs/*:refs/*" &&
git -C mirror.git show-ref |
make_user_friendly_and_stable_output >actual &&
cat >expect <<-\EOF &&
<COMMIT-N> refs/heads/release
<COMMIT-D> refs/heads/topic/1
<COMMIT-H> refs/heads/topic/2
EOF
test_cmp expect actual &&
git -C mirror.git fetch ../3.bdl "+refs/*:refs/*" &&
git -C mirror.git show-ref |
make_user_friendly_and_stable_output >actual &&
cat >expect <<-\EOF &&
<COMMIT-P> refs/heads/main
<COMMIT-N> refs/heads/release
<COMMIT-D> refs/heads/topic/1
<COMMIT-H> refs/heads/topic/2
EOF
test_cmp expect actual &&
git -C mirror.git fetch ../4.bdl "+refs/*:refs/*" &&
git -C mirror.git show-ref |
make_user_friendly_and_stable_output >actual &&
cat >expect <<-\EOF &&
<COMMIT-P> refs/heads/main
<COMMIT-N> refs/heads/release
<COMMIT-D> refs/heads/topic/1
<COMMIT-H> refs/heads/topic/2
<TAG-1> refs/tags/v1
<TAG-2> refs/tags/v2
<TAG-3> refs/tags/v3
EOF
test_cmp expect actual
'
test_expect_success 'unfiltered bundle with --objects' '
git bundle create all-objects.bdl \
--all --objects &&
git bundle create all.bdl \
--all &&
# Compare the headers of these files.
sed -n -e "/^$/q" -e "p" all.bdl >expect &&
sed -n -e "/^$/q" -e "p" all-objects.bdl >actual &&
test_cmp expect actual
'
test_expect_success 'full bundle upto annotated tag' '
git bundle create v2.bdl \
v2 &&
git bundle verify v2.bdl |
make_user_friendly_and_stable_output >actual &&
format_and_save_expect <<-EOF &&
The bundle contains this ref:
<TAG-2> refs/tags/v2
The bundle records a complete history.
$HASH_MESSAGE
EOF
test_cmp expect actual
'
test_expect_success 'clone from full bundle upto annotated tag' '
git clone --mirror v2.bdl tag-clone.git &&
git -C tag-clone.git show-ref |
make_user_friendly_and_stable_output >actual &&
cat >expect <<-\EOF &&
<TAG-2> refs/tags/v2
EOF
test_cmp expect actual
'
test_expect_success 'incremental bundle between two annotated tags' '
git bundle create v1-v2.bdl \
v1..v2 &&
git bundle verify v1-v2.bdl |
make_user_friendly_and_stable_output >actual &&
format_and_save_expect <<-EOF &&
The bundle contains this ref:
<TAG-2> refs/tags/v2
The bundle requires these 2 refs:
<COMMIT-E> Z
<COMMIT-B> Z
$HASH_MESSAGE
EOF
test_cmp expect actual
'
for filter in "blob:none" "tree:0" "tree:1" "blob:limit=100"
do
test_expect_success "filtered bundle: $filter" '
test_when_finished rm -rf .git/objects/pack cloned unbundled &&
git bundle create partial.bdl \
--all \
--filter=$filter &&
git bundle verify partial.bdl >unfiltered &&
make_user_friendly_and_stable_output <unfiltered >actual &&
cat >expect <<-EOF &&
The bundle contains these 10 refs:
<COMMIT-P> refs/heads/main
<COMMIT-N> refs/heads/release
<COMMIT-D> refs/heads/topic/1
<COMMIT-H> refs/heads/topic/2
<COMMIT-D> refs/pull/1/head
<COMMIT-G> refs/pull/2/head
<TAG-1> refs/tags/v1
<TAG-2> refs/tags/v2
<TAG-3> refs/tags/v3
<COMMIT-P> HEAD
The bundle records a complete history.
$HASH_MESSAGE
The bundle uses this filter: $filter
EOF
test_cmp expect actual &&
test_config uploadpack.allowfilter 1 &&
test_config uploadpack.allowanysha1inwant 1 &&
git clone --no-local --filter=$filter --bare "file://$(pwd)" cloned &&
git init unbundled &&
git -C unbundled bundle unbundle ../partial.bdl >ref-list.txt &&
ls unbundled/.git/objects/pack/pack-*.promisor >promisor &&
test_line_count = 1 promisor &&
# Count the same number of reachable objects.
reflist=$(git for-each-ref --format="%(objectname)") &&
git rev-list --objects --filter=$filter --missing=allow-any \
$reflist >expect &&
for repo in cloned unbundled
do
git -C $repo rev-list --objects --missing=allow-any \
$reflist >actual &&
test_cmp expect actual || return 1
done
'
done
# NEEDSWORK: 'git clone --bare' should be able to clone from a filtered
# bundle, but that requires a change to promisor/filter config options.
# For now, we fail gracefully with a helpful error. This behavior can be
# changed in the future to succeed as much as possible.
test_expect_success 'cloning from filtered bundle has useful error' '
git bundle create partial.bdl \
--all \
--filter=blob:none &&
test_must_fail git clone --bare partial.bdl partial 2>err &&
grep "cannot clone from filtered bundle" err
'
test_expect_success 'verify catches unreachable, broken prerequisites' '
test_when_finished rm -rf clone-from clone-to &&
git init clone-from &&
(
cd clone-from &&
git checkout -b base &&
test_commit A &&
git checkout -b tip &&
git commit --allow-empty -m "will drop by shallow" &&
git commit --allow-empty -m "will keep by shallow" &&
git commit --allow-empty -m "for bundle, not clone" &&
git bundle create tip.bundle tip~1..tip &&
git reset --hard HEAD~1 &&
git checkout base
) &&
BAD_OID=$(git -C clone-from rev-parse tip~1) &&
TIP_OID=$(git -C clone-from rev-parse tip) &&
git clone --depth=1 --no-single-branch \
"file://$(pwd)/clone-from" clone-to &&
(
cd clone-to &&
# Set up broken history by removing shallow markers
git update-ref -d refs/remotes/origin/tip &&
rm .git/shallow &&
# Verify should fail
test_must_fail git bundle verify \
../clone-from/tip.bundle 2>err &&
grep "some prerequisite commits .* are not connected" err &&
test_line_count = 1 err &&
# Unbundling should fail
test_must_fail git bundle unbundle \
../clone-from/tip.bundle 2>err &&
grep "some prerequisite commits .* are not connected" err &&
test_line_count = 1 err
)
'
test_expect_success 'bundle progress includes write phase' '
GIT_PROGRESS_DELAY=0 \
git bundle create --progress out.bundle --all 2>err &&
grep 'Writing' err
'
test_expect_success TTY 'create --quiet disables all bundle progress' '
test_terminal env GIT_PROGRESS_DELAY=0 \
git bundle create --quiet out.bundle --all 2>err &&
test_must_be_empty err
'
test_expect_success 'bundle progress with --no-quiet' '
GIT_PROGRESS_DELAY=0 \
git bundle create --no-quiet out.bundle --all 2>err &&
grep "%" err
'
test_expect_success 'read bundle over stdin' '
git bundle create some.bundle HEAD &&
git bundle verify - <some.bundle 2>err &&
grep "<stdin> is okay" err &&
git bundle list-heads some.bundle >expect &&
git bundle list-heads - <some.bundle >actual &&
test_cmp expect actual &&
git bundle unbundle some.bundle >expect &&
git bundle unbundle - <some.bundle >actual &&
test_cmp expect actual
'
test_expect_success 'send a bundle to standard output' '
git bundle create - --all HEAD >bundle-one &&
mkdir -p down &&
git -C down bundle create - --all HEAD >bundle-two &&
git bundle verify bundle-one &&
git bundle verify bundle-two &&
git ls-remote bundle-one >expect &&
git ls-remote bundle-two >actual &&
test_cmp expect actual
'
test_expect_success 'unbundle outside of a repository' '
git bundle create some.bundle HEAD &&
echo "fatal: Need a repository to unbundle." >expect &&
nongit test_must_fail git bundle unbundle "$(pwd)/some.bundle" 2>err &&
test_cmp expect err
'
test_expect_success 'list-heads outside of a repository' '
git bundle create some.bundle HEAD &&
cat >expect <<-EOF &&
$(git rev-parse HEAD) HEAD
EOF
nongit git bundle list-heads "$(pwd)/some.bundle" >actual &&
test_cmp expect actual
'
for hash in sha1 sha256
do
test_expect_success "list-heads with bundle using $hash" '
test_when_finished "rm -rf hash" &&
git init --object-format=$hash hash &&
test_commit -C hash initial &&
git -C hash bundle create hash.bundle HEAD &&
cat >expect <<-EOF &&
$(git -C hash rev-parse HEAD) HEAD
EOF
git bundle list-heads hash/hash.bundle >actual &&
test_cmp expect actual
'
done
test_done
Reference in New Issue View Git Blame Copy Permalink