mirror of
https://github.com/git/git.git
synced 2026-08-07 00:22:05 +00:00
cdaf12f762
The standard philosophy for Unix software when a help option (such as --help) is specified is that the software should exit 0, printing the help output to standard output, since the standard output is for user-requested output and the program performed the requested task successfully. If the user specifies an incorrect option, then the help output should be printed to standard error (since the user has made a mistake) and it should exit unsuccessfully. Most of our commands currently exit 129 on receiving the -h option to print the short help, which does not line up with the standard philosophy above. Let's change that to exit 0 instead. This requires changes to a variety of tests which previously wanted the 129 exit code, so update them. Note that because git diff does its own option parsing, it still exits with 129, so update some of the tests to expect either exit status. Some commands also now pass with -h but not --help-all, so handle those cases differently for those commands. Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>
1952 lines
67 KiB
Bash
Executable File
1952 lines
67 KiB
Bash
Executable File
#!/bin/sh
|
|
#
|
|
# Copyright (c) 2012 Avery Pennaraum
|
|
# Copyright (c) 2015 Alexey Shumkin
|
|
#
|
|
test_description='Basic porcelain support for subtrees
|
|
|
|
This test verifies the basic operation of the add, merge, split, pull,
|
|
and push subcommands of git subtree.
|
|
'
|
|
|
|
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
|
|
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
|
|
|
|
TEST_DIRECTORY=$(pwd)/../../../t
|
|
. "$TEST_DIRECTORY"/test-lib.sh
|
|
. "$TEST_DIRECTORY"/lib-gpg.sh
|
|
|
|
# Use our own wrapper around test-lib.sh's test_create_repo, in order
|
|
# to set log.date=relative. `git subtree` parses the output of `git
|
|
# log`, and so it must be careful to not be affected by settings that
|
|
# change the `git log` output. We test this by setting
|
|
# log.date=relative for every repo in the tests.
|
|
subtree_test_create_repo () {
|
|
test_create_repo "$1" &&
|
|
git -C "$1" config log.date relative
|
|
}
|
|
|
|
test_create_commit () (
|
|
repo=$1 &&
|
|
commit=$2 &&
|
|
cd "$repo" &&
|
|
mkdir -p "$(dirname "$commit")" \
|
|
|| error "Could not create directory for commit"
|
|
echo "$commit" >"$commit" &&
|
|
git add "$commit" || error "Could not add commit"
|
|
git commit -m "$commit" || error "Could not commit"
|
|
)
|
|
|
|
test_wrong_flag() {
|
|
test_must_fail "$@" >out 2>err &&
|
|
test_must_be_empty out &&
|
|
grep "flag does not make sense with" err
|
|
}
|
|
|
|
last_commit_subject () {
|
|
git log --pretty=format:%s -1
|
|
}
|
|
|
|
# Upon 'git subtree add|merge --squash' of an annotated tag,
|
|
# pre-2.32.0 versions of 'git subtree' would write the hash of the tag
|
|
# (sub1 below), instead of the commit (sub1^{commit}) in the
|
|
# "git-subtree-split" trailer.
|
|
# We imitate this behaviour below using a replace ref.
|
|
# This function creates 3 repositories:
|
|
# - $1
|
|
# - $1-sub (added as subtree "sub" in $1)
|
|
# - $1-clone (clone of $1)
|
|
test_create_pre2_32_repo () {
|
|
subtree_test_create_repo "$1" &&
|
|
subtree_test_create_repo "$1-sub" &&
|
|
test_commit -C "$1" main1 &&
|
|
test_commit -C "$1-sub" --annotate sub1 &&
|
|
git -C "$1" subtree add --prefix="sub" --squash "../$1-sub" sub1 &&
|
|
tag=$(git -C "$1" rev-parse FETCH_HEAD) &&
|
|
commit=$(git -C "$1" rev-parse FETCH_HEAD^{commit}) &&
|
|
git -C "$1" log -1 --format=%B HEAD^2 >msg &&
|
|
test_commit -C "$1-sub" --annotate sub2 &&
|
|
git clone --no-local "$1" "$1-clone" &&
|
|
new_commit=$(sed -e "s/$commit/$tag/" msg | git -C "$1-clone" commit-tree HEAD^2^{tree}) &&
|
|
git -C "$1-clone" replace HEAD^2 $new_commit
|
|
}
|
|
|
|
# test_create_subtree_add REPO ORPHAN PREFIX FILENAME ...
|
|
#
|
|
# Create a simple subtree on a new branch named ORPHAN in REPO.
|
|
# The subtree is then merged into the current branch of REPO,
|
|
# under PREFIX. The generated subtree has one commit
|
|
# with subject and tag FILENAME with a single file "FILENAME.t"
|
|
#
|
|
# When this method returns:
|
|
# - the current branch of REPO will have file PREFIX/FILENAME.t
|
|
# - REPO will have a branch named ORPHAN with subtree history
|
|
#
|
|
# additional arguments are forwarded to "subtree add"
|
|
test_create_subtree_add () {
|
|
(
|
|
cd "$1" &&
|
|
orphan="$2" &&
|
|
prefix="$3" &&
|
|
filename="$4" &&
|
|
shift 4 &&
|
|
last="$(git branch --show-current)" &&
|
|
git switch --orphan "$orphan" &&
|
|
test_commit "$filename" &&
|
|
git checkout "$last" &&
|
|
git subtree add --prefix="$prefix" "$@" "$orphan"
|
|
)
|
|
}
|
|
|
|
test_expect_success 'shows short help text for -h' '
|
|
git subtree -h >out 2>err &&
|
|
test_must_be_empty err &&
|
|
grep -e "^ *or: git subtree pull" out &&
|
|
grep -F -e "--[no-]annotate" out
|
|
'
|
|
|
|
#
|
|
# Tests for 'git subtree add'
|
|
#
|
|
|
|
test_expect_success 'no merge from non-existent subtree' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
test_must_fail git subtree merge --prefix="sub dir" FETCH_HEAD
|
|
)
|
|
'
|
|
|
|
test_expect_success 'no pull from non-existent subtree' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
test_must_fail git subtree pull --prefix="sub dir" ./"sub proj" HEAD
|
|
)
|
|
'
|
|
|
|
test_expect_success 'add rejects flags for split' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
test_wrong_flag git subtree add --prefix="sub dir" --annotate=foo FETCH_HEAD &&
|
|
test_wrong_flag git subtree add --prefix="sub dir" --branch=foo FETCH_HEAD &&
|
|
test_wrong_flag git subtree add --prefix="sub dir" --ignore-joins FETCH_HEAD &&
|
|
test_wrong_flag git subtree add --prefix="sub dir" --onto=foo FETCH_HEAD &&
|
|
test_wrong_flag git subtree add --prefix="sub dir" --rejoin FETCH_HEAD
|
|
)
|
|
'
|
|
|
|
test_expect_success 'add subproj as subtree into sub dir/ with --prefix' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD &&
|
|
test "$(last_commit_subject)" = "Add '\''sub dir/'\'' from commit '\''$(git rev-parse FETCH_HEAD)'\''"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'add subproj as subtree into sub dir/ with --prefix and --message' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" --message="Added subproject" FETCH_HEAD &&
|
|
test "$(last_commit_subject)" = "Added subproject"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'add subproj as subtree into sub dir/ with --prefix as -P and --message as -m' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add -P "sub dir" -m "Added subproject" FETCH_HEAD &&
|
|
test "$(last_commit_subject)" = "Added subproject"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'add subproj as subtree into sub dir/ with --squash and --prefix and --message' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" --message="Added subproject with squash" --squash FETCH_HEAD &&
|
|
test "$(last_commit_subject)" = "Added subproject with squash"
|
|
)
|
|
'
|
|
|
|
#
|
|
# Tests for 'git subtree merge'
|
|
#
|
|
|
|
test_expect_success 'merge rejects flags for split' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
test_wrong_flag git subtree merge --prefix="sub dir" --annotate=foo FETCH_HEAD &&
|
|
test_wrong_flag git subtree merge --prefix="sub dir" --branch=foo FETCH_HEAD &&
|
|
test_wrong_flag git subtree merge --prefix="sub dir" --ignore-joins FETCH_HEAD &&
|
|
test_wrong_flag git subtree merge --prefix="sub dir" --onto=foo FETCH_HEAD &&
|
|
test_wrong_flag git subtree merge --prefix="sub dir" --rejoin FETCH_HEAD
|
|
)
|
|
'
|
|
|
|
test_expect_success 'merge new subproj history into sub dir/ with --prefix' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
test "$(last_commit_subject)" = "Merge commit '\''$(git rev-parse FETCH_HEAD)'\''"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'merge new subproj history into sub dir/ with --prefix and --message' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" --message="Merged changes from subproject" FETCH_HEAD &&
|
|
test "$(last_commit_subject)" = "Merged changes from subproject"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'merge new subproj history into sub dir/ with --squash and --prefix and --message' '
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
subtree_test_create_repo "$test_count" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" --message="Merged changes from subproject using squash" --squash FETCH_HEAD &&
|
|
test "$(last_commit_subject)" = "Merged changes from subproject using squash"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'merge the added subproj again, should do nothing' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD &&
|
|
# this shouldn not actually do anything, since FETCH_HEAD
|
|
# is already a parent
|
|
result=$(git merge -s ours -m "merge -s -ours" FETCH_HEAD) &&
|
|
test "${result}" = "Already up to date."
|
|
)
|
|
'
|
|
|
|
test_expect_success 'merge new subproj history into subdir/ with a slash appended to the argument of --prefix' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/subproj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/subproj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./subproj HEAD &&
|
|
git subtree add --prefix=subdir/ FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/subproj" sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./subproj HEAD &&
|
|
git subtree merge --prefix=subdir/ FETCH_HEAD &&
|
|
test "$(last_commit_subject)" = "Merge commit '\''$(git rev-parse FETCH_HEAD)'\''"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'merge with --squash after annotated tag was added/merged with --squash pre-v2.32.0 ' '
|
|
test_create_pre2_32_repo "$test_count" &&
|
|
git -C "$test_count-clone" fetch "../$test_count-sub" sub2 &&
|
|
test_must_fail git -C "$test_count-clone" subtree merge --prefix="sub" --squash FETCH_HEAD &&
|
|
git -C "$test_count-clone" subtree merge --prefix="sub" --squash FETCH_HEAD "../$test_count-sub"
|
|
'
|
|
|
|
#
|
|
# Tests for 'git subtree split'
|
|
#
|
|
|
|
test_expect_success 'split requires option --prefix' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD &&
|
|
echo "fatal: you must provide the --prefix option." >expected &&
|
|
test_must_fail git subtree split >actual 2>&1 &&
|
|
test_debug "printf '"expected: "'" &&
|
|
test_debug "cat expected" &&
|
|
test_debug "printf '"actual: "'" &&
|
|
test_debug "cat actual" &&
|
|
test_cmp expected actual
|
|
)
|
|
'
|
|
|
|
test_expect_success 'split requires path given by option --prefix must exist' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD &&
|
|
echo "fatal: '\''non-existent-directory'\'' does not exist; use '\''git subtree add'\''" >expected &&
|
|
test_must_fail git subtree split --prefix=non-existent-directory >actual 2>&1 &&
|
|
test_debug "printf '"expected: "'" &&
|
|
test_debug "cat expected" &&
|
|
test_debug "printf '"actual: "'" &&
|
|
test_debug "cat actual" &&
|
|
test_cmp expected actual
|
|
)
|
|
'
|
|
|
|
test_expect_success 'split works when prefix exists in commit but not in working tree' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
(
|
|
cd "$test_count" &&
|
|
|
|
# create subtree
|
|
mkdir pkg &&
|
|
echo ok >pkg/file &&
|
|
git add pkg &&
|
|
git commit -m "add pkg" &&
|
|
good=$(git rev-parse HEAD) &&
|
|
|
|
# remove it from working tree in later commit
|
|
git rm -r pkg &&
|
|
git commit -m "remove pkg" &&
|
|
|
|
# must still be able to split using the old commit
|
|
git subtree split --prefix=pkg "$good" >out &&
|
|
test -s out
|
|
)
|
|
'
|
|
|
|
test_expect_success 'split rejects flags for add' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
split_hash=$(git subtree split --prefix="sub dir" --annotate="*") &&
|
|
test_wrong_flag git subtree split --prefix="sub dir" --squash &&
|
|
test_wrong_flag git subtree split --prefix="sub dir" --message=foo
|
|
)
|
|
'
|
|
|
|
test_expect_success 'split sub dir/ with --rejoin' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
split_hash=$(git subtree split --prefix="sub dir" --annotate="*") &&
|
|
git subtree split --prefix="sub dir" --annotate="*" -b spl --rejoin &&
|
|
test "$(last_commit_subject)" = "Split '\''sub dir/'\'' into commit '\''$split_hash'\''" &&
|
|
test "$(git rev-list --count spl)" -eq 5
|
|
)
|
|
'
|
|
|
|
# Tests that commits from other subtrees are not processed as
|
|
# part of a split.
|
|
#
|
|
# This test performs the following:
|
|
# - Creates Repo with subtrees 'subA' and 'subB'
|
|
# - Creates commits in the repo including changes to subtrees
|
|
# - Runs the following 'split' and commit' commands in order:
|
|
# - Perform 'split' on subtree A
|
|
# - Perform 'split' on subtree B
|
|
# - Create new commits with changes to subtree A and B
|
|
# - Perform split on subtree A
|
|
# - Check for expected history
|
|
test_expect_success 'split with multiple subtrees' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/subA" &&
|
|
subtree_test_create_repo "$test_count/subB" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/subA" subA1 &&
|
|
test_create_commit "$test_count/subA" subA2 &&
|
|
test_create_commit "$test_count/subA" subA3 &&
|
|
test_create_commit "$test_count/subB" subB1 &&
|
|
git -C "$test_count" fetch ./subA HEAD &&
|
|
git -C "$test_count" subtree add --prefix=subADir FETCH_HEAD &&
|
|
git -C "$test_count" fetch ./subB HEAD &&
|
|
git -C "$test_count" subtree add --prefix=subBDir FETCH_HEAD &&
|
|
test "$(git -C "$test_count" rev-list --count main)" -eq 7 &&
|
|
test_create_commit "$test_count" subADir/main-subA1 &&
|
|
test_create_commit "$test_count" subBDir/main-subB1 &&
|
|
git -C "$test_count" subtree split --prefix=subADir \
|
|
--squash --rejoin -m "Sub A Split 1" -b a1 &&
|
|
test "$(git -C "$test_count" rev-list --count main..a1)" -eq 1 &&
|
|
git -C "$test_count" subtree split --prefix=subBDir \
|
|
--squash --rejoin -m "Sub B Split 1" -b b1 &&
|
|
test "$(git -C "$test_count" rev-list --count main..b1)" -eq 1 &&
|
|
test_create_commit "$test_count" subADir/main-subA2 &&
|
|
test_create_commit "$test_count" subBDir/main-subB2 &&
|
|
git -C "$test_count" subtree split --prefix=subADir \
|
|
--squash --rejoin -m "Sub A Split 2" -b a2 &&
|
|
test "$(git -C "$test_count" rev-list --count main..a2)" -eq 2 &&
|
|
test "$(git -C "$test_count" rev-list --count a1..a2)" -eq 1 &&
|
|
git -C "$test_count" subtree split --prefix=subBDir \
|
|
--squash --rejoin -d -m "Sub B Split 1" -b b2 &&
|
|
test "$(git -C "$test_count" rev-list --count main..b2)" -eq 2 &&
|
|
test "$(git -C "$test_count" rev-list --count b1..b2)" -eq 1
|
|
'
|
|
|
|
# When subtree split-ing a directory that has other subtree
|
|
# *merges* underneath it, the split must include those subtrees.
|
|
# This test creates a nested subtree, `subA/subB`, and tests
|
|
# that the tree is correct after a subtree split of `subA/`.
|
|
# The test covers:
|
|
# - An initial `subtree add`; and
|
|
# - A follow-up `subtree merge`
|
|
# both with and without `--squashed`.
|
|
for is_squashed in '' 'y'
|
|
do
|
|
test_expect_success "split keeps nested ${is_squashed:+--squash }subtrees that are part of the split" '
|
|
subtree_test_create_repo "$test_count" &&
|
|
(
|
|
cd "$test_count" &&
|
|
mkdir subA &&
|
|
test_commit subA/file1 &&
|
|
test_create_subtree_add \
|
|
. mksubtree subA/subB file2 ${is_squashed:+--squash} &&
|
|
test_path_is_file subA/file1.t &&
|
|
test_path_is_file subA/subB/file2.t &&
|
|
git subtree split --prefix=subA --branch=bsplit &&
|
|
test "$(git rev-list --count bsplit)" -eq 2 &&
|
|
git checkout bsplit &&
|
|
test_path_is_file file1.t &&
|
|
test_path_is_file subB/file2.t &&
|
|
git checkout mksubtree &&
|
|
git branch -D bsplit &&
|
|
test_commit file3 &&
|
|
git checkout main &&
|
|
git subtree merge \
|
|
${is_squashed:+--squash} \
|
|
--prefix=subA/subB mksubtree &&
|
|
test_path_is_file subA/subB/file3.t &&
|
|
git subtree split --prefix=subA --branch=bsplit &&
|
|
test "$(git rev-list --count bsplit)" -eq 3 &&
|
|
git checkout bsplit &&
|
|
test_path_is_file file1.t &&
|
|
test_path_is_file subB/file2.t &&
|
|
test_path_is_file subB/file3.t
|
|
)
|
|
'
|
|
done
|
|
|
|
# Usually,
|
|
#
|
|
# git subtree merge -P subA --squash f00...
|
|
#
|
|
# makes two commits, in this order:
|
|
#
|
|
# 1. Squashed 'subA/' content from commit f00...
|
|
# 2. Merge commit (1) as 'subA'
|
|
#
|
|
# Commit 1 updates the subtree but does *not* rewrite paths.
|
|
# Commit 2 rewrites all trees to start with `subA/`
|
|
#
|
|
# Commit 1 either has no parents or depends only on other
|
|
# "Squashed 'subA/' content" commits.
|
|
#
|
|
# For merge without --squash, subtree produces just one commit:
|
|
# a merge commit with git-subtree trailers.
|
|
#
|
|
# In either case, if the user rebases these commits, they will
|
|
# still have the git-subtree-* trailers… but will NOT have
|
|
# the layout described above.
|
|
#
|
|
# Test that subsequent `git subtree split` are not confused by this.
|
|
test_expect_success 'split with rebased subtree commit' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
(
|
|
cd "$test_count" &&
|
|
test_commit file0 &&
|
|
test_create_subtree_add \
|
|
. mksubtree subA file1 --squash &&
|
|
test_path_is_file subA/file1.t &&
|
|
mkdir subB &&
|
|
test_commit subB/bfile &&
|
|
git commit --amend -F - <<'EOF' &&
|
|
Squashed '\''subB/'\'' content from commit '\''badf00da911bbe895347b4b236f5461d55dc9877'\''
|
|
|
|
Simulate a cherry-picked or rebased subtree commit.
|
|
|
|
git-subtree-dir: subB
|
|
git-subtree-split: badf00da911bbe895347b4b236f5461d55dc9877
|
|
EOF
|
|
test_commit subA/file2 &&
|
|
test_commit subB/bfile2 &&
|
|
git commit --amend -F - <<'EOF' &&
|
|
Split '\''subB/'\'' into commit '\''badf00da911bbe895347b4b236f5461d55dc9877'\''
|
|
|
|
Simulate a cherry-picked or rebased subtree commit.
|
|
|
|
git-subtree-dir: subB
|
|
git-subtree-mainline: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
|
|
git-subtree-split: badf00da911bbe895347b4b236f5461d55dc9877
|
|
EOF
|
|
git subtree split --prefix=subA --branch=bsplit &&
|
|
git checkout bsplit &&
|
|
test_path_is_file file1.t &&
|
|
test_path_is_file file2.t &&
|
|
test "$(last_commit_subject)" = "subA/file2" &&
|
|
test "$(git rev-list --count bsplit)" -eq 2
|
|
)
|
|
'
|
|
|
|
test_expect_success 'split sub dir/ with --rejoin from scratch' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
mkdir "sub dir" &&
|
|
echo file >"sub dir"/file &&
|
|
git add "sub dir/file" &&
|
|
git commit -m"sub dir file" &&
|
|
split_hash=$(git subtree split --prefix="sub dir" --rejoin) &&
|
|
git subtree split --prefix="sub dir" --rejoin &&
|
|
test "$(last_commit_subject)" = "Split '\''sub dir/'\'' into commit '\''$split_hash'\''"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'split sub dir/ with --rejoin and --message' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
git subtree split --prefix="sub dir" --message="Split & rejoin" --annotate="*" --rejoin &&
|
|
test "$(last_commit_subject)" = "Split & rejoin"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'split "sub dir"/ with --rejoin and --squash' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" --squash FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree pull --prefix="sub dir" --squash ./"sub proj" HEAD &&
|
|
MAIN=$(git rev-parse --verify HEAD) &&
|
|
SUB=$(git -C "sub proj" rev-parse --verify HEAD) &&
|
|
|
|
SPLIT=$(git subtree split --prefix="sub dir" --annotate="*" --rejoin --squash) &&
|
|
|
|
test_must_fail git merge-base --is-ancestor $SUB HEAD &&
|
|
test_must_fail git merge-base --is-ancestor $SPLIT HEAD &&
|
|
git rev-list HEAD ^$MAIN >commit-list &&
|
|
test_line_count = 2 commit-list &&
|
|
test "$(git rev-parse --verify HEAD:)" = "$(git rev-parse --verify $MAIN:)" &&
|
|
test "$(git rev-parse --verify HEAD:"sub dir")" = "$(git rev-parse --verify $SPLIT:)" &&
|
|
test "$(git rev-parse --verify HEAD^1)" = $MAIN &&
|
|
test "$(git rev-parse --verify HEAD^2)" != $SPLIT &&
|
|
test "$(git rev-parse --verify HEAD^2:)" = "$(git rev-parse --verify $SPLIT:)" &&
|
|
test "$(last_commit_subject)" = "Split '\''sub dir/'\'' into commit '\''$SPLIT'\''"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'split then pull "sub dir"/ with --rejoin and --squash' '
|
|
# 1. "add"
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
git -C "$test_count" subtree --prefix="sub dir" add --squash ./"sub proj" HEAD &&
|
|
|
|
# 2. commit from parent
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
|
|
# 3. "split --rejoin --squash"
|
|
git -C "$test_count" subtree --prefix="sub dir" split --rejoin --squash &&
|
|
|
|
# 4. "pull --squash"
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
git -C "$test_count" subtree -d --prefix="sub dir" pull --squash ./"sub proj" HEAD &&
|
|
|
|
test_must_fail git merge-base HEAD FETCH_HEAD
|
|
'
|
|
|
|
test_expect_success 'split "sub dir"/ with --branch' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
split_hash=$(git subtree split --prefix="sub dir" --annotate="*") &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br &&
|
|
test "$(git rev-parse subproj-br)" = "$split_hash"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'check hash of split' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
split_hash=$(git subtree split --prefix="sub dir" --annotate="*") &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br &&
|
|
test "$(git rev-parse subproj-br)" = "$split_hash" &&
|
|
# Check hash of split
|
|
new_hash=$(git rev-parse subproj-br^2) &&
|
|
(
|
|
cd ./"sub proj" &&
|
|
subdir_hash=$(git rev-parse HEAD) &&
|
|
test "$new_hash" = "$subdir_hash"
|
|
)
|
|
)
|
|
'
|
|
|
|
test_expect_success 'split "sub dir"/ with --branch for an existing branch' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git branch subproj-br FETCH_HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
split_hash=$(git subtree split --prefix="sub dir" --annotate="*") &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br &&
|
|
test "$(git rev-parse subproj-br)" = "$split_hash"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'split "sub dir"/ with --branch for an incompatible branch' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git branch init HEAD &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
test_must_fail git subtree split --prefix="sub dir" --branch init
|
|
)
|
|
'
|
|
|
|
test_expect_success 'split after annotated tag was added/merged with --squash pre-v2.32.0' '
|
|
test_create_pre2_32_repo "$test_count" &&
|
|
test_must_fail git -C "$test_count-clone" subtree split --prefix="sub" HEAD &&
|
|
git -C "$test_count-clone" subtree split --prefix="sub" HEAD "../$test_count-sub"
|
|
'
|
|
|
|
#
|
|
# Tests for 'git subtree pull'
|
|
#
|
|
|
|
test_expect_success 'pull requires option --prefix' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
test_must_fail git subtree pull ./"sub proj" HEAD >out 2>err &&
|
|
|
|
echo "fatal: you must provide the --prefix option." >expected &&
|
|
test_must_be_empty out &&
|
|
test_cmp expected err
|
|
)
|
|
'
|
|
|
|
test_expect_success 'pull requires path given by option --prefix must exist' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
test_must_fail git subtree pull --prefix="sub dir" ./"sub proj" HEAD >out 2>err &&
|
|
|
|
echo "fatal: '\''sub dir'\'' does not exist; use '\''git subtree add'\''" >expected &&
|
|
test_must_be_empty out &&
|
|
test_cmp expected err
|
|
)
|
|
'
|
|
|
|
test_expect_success 'pull basic operation' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
exp=$(git -C "sub proj" rev-parse --verify HEAD:) &&
|
|
git subtree pull --prefix="sub dir" ./"sub proj" HEAD &&
|
|
act=$(git rev-parse --verify HEAD:"sub dir") &&
|
|
test "$act" = "$exp"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'pull rejects flags for split' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
(
|
|
test_must_fail git subtree pull --prefix="sub dir" --annotate=foo ./"sub proj" HEAD &&
|
|
test_must_fail git subtree pull --prefix="sub dir" --branch=foo ./"sub proj" HEAD &&
|
|
test_must_fail git subtree pull --prefix="sub dir" --ignore-joins ./"sub proj" HEAD &&
|
|
test_must_fail git subtree pull --prefix="sub dir" --onto=foo ./"sub proj" HEAD &&
|
|
test_must_fail git subtree pull --prefix="sub dir" --rejoin ./"sub proj" HEAD
|
|
)
|
|
'
|
|
|
|
test_expect_success 'pull with --squash after annotated tag was added/merged with --squash pre-v2.32.0 ' '
|
|
test_create_pre2_32_repo "$test_count" &&
|
|
git -C "$test_count-clone" subtree -d pull --prefix="sub" --squash "../$test_count-sub" sub2
|
|
'
|
|
|
|
#
|
|
# Tests for 'git subtree push'
|
|
#
|
|
|
|
test_expect_success 'push requires option --prefix' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD &&
|
|
echo "fatal: you must provide the --prefix option." >expected &&
|
|
test_must_fail git subtree push "./sub proj" from-mainline >actual 2>&1 &&
|
|
test_debug "printf '"expected: "'" &&
|
|
test_debug "cat expected" &&
|
|
test_debug "printf '"actual: "'" &&
|
|
test_debug "cat actual" &&
|
|
test_cmp expected actual
|
|
)
|
|
'
|
|
|
|
test_expect_success 'push requires path given by option --prefix must exist' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD &&
|
|
echo "fatal: '\''non-existent-directory'\'' does not exist; use '\''git subtree add'\''" >expected &&
|
|
test_must_fail git subtree push --prefix=non-existent-directory "./sub proj" from-mainline >actual 2>&1 &&
|
|
test_debug "printf '"expected: "'" &&
|
|
test_debug "cat expected" &&
|
|
test_debug "printf '"actual: "'" &&
|
|
test_debug "cat actual" &&
|
|
test_cmp expected actual
|
|
)
|
|
'
|
|
|
|
test_expect_success 'push rejects flags for add' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
test_wrong_flag git subtree split --prefix="sub dir" --squash ./"sub proj" from-mainline &&
|
|
test_wrong_flag git subtree split --prefix="sub dir" --message=foo ./"sub proj" from-mainline
|
|
)
|
|
'
|
|
|
|
test_expect_success 'push basic operation' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
before=$(git rev-parse --verify HEAD) &&
|
|
split_hash=$(git subtree split --prefix="sub dir") &&
|
|
git subtree push --prefix="sub dir" ./"sub proj" from-mainline &&
|
|
test "$before" = "$(git rev-parse --verify HEAD)" &&
|
|
test "$split_hash" = "$(git -C "sub proj" rev-parse --verify refs/heads/from-mainline)"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'push sub dir/ with --rejoin' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
split_hash=$(git subtree split --prefix="sub dir" --annotate="*") &&
|
|
git subtree push --prefix="sub dir" --annotate="*" --rejoin ./"sub proj" from-mainline &&
|
|
test "$(last_commit_subject)" = "Split '\''sub dir/'\'' into commit '\''$split_hash'\''" &&
|
|
test "$split_hash" = "$(git -C "sub proj" rev-parse --verify refs/heads/from-mainline)"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'push sub dir/ with --rejoin from scratch' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
mkdir "sub dir" &&
|
|
echo file >"sub dir"/file &&
|
|
git add "sub dir/file" &&
|
|
git commit -m"sub dir file" &&
|
|
split_hash=$(git subtree split --prefix="sub dir" --rejoin) &&
|
|
git init --bare "sub proj.git" &&
|
|
git subtree push --prefix="sub dir" --rejoin ./"sub proj.git" from-mainline &&
|
|
test "$(last_commit_subject)" = "Split '\''sub dir/'\'' into commit '\''$split_hash'\''" &&
|
|
test "$split_hash" = "$(git -C "sub proj.git" rev-parse --verify refs/heads/from-mainline)"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'push sub dir/ with --rejoin and --message' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
git subtree push --prefix="sub dir" --message="Split & rejoin" --annotate="*" --rejoin ./"sub proj" from-mainline &&
|
|
test "$(last_commit_subject)" = "Split & rejoin" &&
|
|
split_hash="$(git rev-parse --verify HEAD^2)" &&
|
|
test "$split_hash" = "$(git -C "sub proj" rev-parse --verify refs/heads/from-mainline)"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'push "sub dir"/ with --rejoin and --squash' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" --squash FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree pull --prefix="sub dir" --squash ./"sub proj" HEAD &&
|
|
MAIN=$(git rev-parse --verify HEAD) &&
|
|
SUB=$(git -C "sub proj" rev-parse --verify HEAD) &&
|
|
|
|
SPLIT=$(git subtree split --prefix="sub dir" --annotate="*") &&
|
|
git subtree push --prefix="sub dir" --annotate="*" --rejoin --squash ./"sub proj" from-mainline &&
|
|
|
|
test_must_fail git merge-base --is-ancestor $SUB HEAD &&
|
|
test_must_fail git merge-base --is-ancestor $SPLIT HEAD &&
|
|
git rev-list HEAD ^$MAIN >commit-list &&
|
|
test_line_count = 2 commit-list &&
|
|
test "$(git rev-parse --verify HEAD:)" = "$(git rev-parse --verify $MAIN:)" &&
|
|
test "$(git rev-parse --verify HEAD:"sub dir")" = "$(git rev-parse --verify $SPLIT:)" &&
|
|
test "$(git rev-parse --verify HEAD^1)" = $MAIN &&
|
|
test "$(git rev-parse --verify HEAD^2)" != $SPLIT &&
|
|
test "$(git rev-parse --verify HEAD^2:)" = "$(git rev-parse --verify $SPLIT:)" &&
|
|
test "$(last_commit_subject)" = "Split '\''sub dir/'\'' into commit '\''$SPLIT'\''" &&
|
|
test "$SPLIT" = "$(git -C "sub proj" rev-parse --verify refs/heads/from-mainline)"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'push "sub dir"/ with --branch' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
split_hash=$(git subtree split --prefix="sub dir" --annotate="*") &&
|
|
git subtree push --prefix="sub dir" --annotate="*" --branch subproj-br ./"sub proj" from-mainline &&
|
|
test "$(git rev-parse subproj-br)" = "$split_hash" &&
|
|
test "$split_hash" = "$(git -C "sub proj" rev-parse --verify refs/heads/from-mainline)"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'check hash of push' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
split_hash=$(git subtree split --prefix="sub dir" --annotate="*") &&
|
|
git subtree push --prefix="sub dir" --annotate="*" --branch subproj-br ./"sub proj" from-mainline &&
|
|
test "$(git rev-parse subproj-br)" = "$split_hash" &&
|
|
# Check hash of split
|
|
new_hash=$(git rev-parse subproj-br^2) &&
|
|
(
|
|
cd ./"sub proj" &&
|
|
subdir_hash=$(git rev-parse HEAD) &&
|
|
test "$new_hash" = "$subdir_hash"
|
|
) &&
|
|
test "$split_hash" = "$(git -C "sub proj" rev-parse --verify refs/heads/from-mainline)"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'push "sub dir"/ with --branch for an existing branch' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git branch subproj-br FETCH_HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
split_hash=$(git subtree split --prefix="sub dir" --annotate="*") &&
|
|
git subtree push --prefix="sub dir" --annotate="*" --branch subproj-br ./"sub proj" from-mainline &&
|
|
test "$(git rev-parse subproj-br)" = "$split_hash" &&
|
|
test "$split_hash" = "$(git -C "sub proj" rev-parse --verify refs/heads/from-mainline)"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'push "sub dir"/ with --branch for an incompatible branch' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git branch init HEAD &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
test_must_fail git subtree push --prefix="sub dir" --branch init "./sub proj" from-mainline
|
|
)
|
|
'
|
|
|
|
test_expect_success 'push "sub dir"/ with a local rev' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
bad_tree=$(git rev-parse --verify HEAD:"sub dir") &&
|
|
good_tree=$(git rev-parse --verify HEAD^:"sub dir") &&
|
|
git subtree push --prefix="sub dir" --annotate="*" ./"sub proj" HEAD^:from-mainline &&
|
|
split_tree=$(git -C "sub proj" rev-parse --verify refs/heads/from-mainline:) &&
|
|
test "$split_tree" = "$good_tree"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'push after annotated tag was added/merged with --squash pre-v2.32.0' '
|
|
test_create_pre2_32_repo "$test_count" &&
|
|
test_create_commit "$test_count-clone" sub/main-sub1 &&
|
|
git -C "$test_count-clone" subtree push --prefix="sub" "../$test_count-sub" from-mainline
|
|
'
|
|
|
|
#
|
|
# Validity checking
|
|
#
|
|
|
|
test_expect_success 'make sure exactly the right set of files ends up in the subproj' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub3 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub3 &&
|
|
(
|
|
cd "$test_count/sub proj" &&
|
|
git fetch .. subproj-br &&
|
|
git merge FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub4 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub4 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
(
|
|
cd "$test_count/sub proj" &&
|
|
git fetch .. subproj-br &&
|
|
git merge FETCH_HEAD &&
|
|
|
|
test_write_lines main-sub1 main-sub2 main-sub3 main-sub4 \
|
|
sub1 sub2 sub3 sub4 >expect &&
|
|
git ls-files >actual &&
|
|
test_cmp expect actual
|
|
)
|
|
'
|
|
|
|
test_expect_success 'make sure the subproj *only* contains commits that affect the "sub dir"' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub3 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub3 &&
|
|
(
|
|
cd "$test_count/sub proj" &&
|
|
git fetch .. subproj-br &&
|
|
git merge FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub4 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub4 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
(
|
|
cd "$test_count/sub proj" &&
|
|
git fetch .. subproj-br &&
|
|
git merge FETCH_HEAD &&
|
|
|
|
test_write_lines main-sub1 main-sub2 main-sub3 main-sub4 \
|
|
sub1 sub2 sub3 sub4 >expect &&
|
|
git log --name-only --pretty=format:"" >log &&
|
|
sort <log | sed "/^\$/ d" >actual &&
|
|
test_cmp expect actual
|
|
)
|
|
'
|
|
|
|
test_expect_success 'make sure exactly the right set of files ends up in the mainline' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub3 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub3 &&
|
|
(
|
|
cd "$test_count/sub proj" &&
|
|
git fetch .. subproj-br &&
|
|
git merge FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub4 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub4 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
(
|
|
cd "$test_count/sub proj" &&
|
|
git fetch .. subproj-br &&
|
|
git merge FETCH_HEAD
|
|
) &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree pull --prefix="sub dir" ./"sub proj" HEAD &&
|
|
|
|
test_write_lines main1 main2 >chkm &&
|
|
test_write_lines main-sub1 main-sub2 main-sub3 main-sub4 >chkms &&
|
|
sed "s,^,sub dir/," chkms >chkms_sub &&
|
|
test_write_lines sub1 sub2 sub3 sub4 >chks &&
|
|
sed "s,^,sub dir/," chks >chks_sub &&
|
|
|
|
cat chkm chkms_sub chks_sub >expect &&
|
|
git ls-files >actual &&
|
|
test_cmp expect actual
|
|
)
|
|
'
|
|
|
|
test_expect_success 'make sure each filename changed exactly once in the entire history' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git config log.date relative &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub3 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub3 &&
|
|
(
|
|
cd "$test_count/sub proj" &&
|
|
git fetch .. subproj-br &&
|
|
git merge FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub4 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub4 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
(
|
|
cd "$test_count/sub proj" &&
|
|
git fetch .. subproj-br &&
|
|
git merge FETCH_HEAD
|
|
) &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree pull --prefix="sub dir" ./"sub proj" HEAD &&
|
|
|
|
test_write_lines main1 main2 >chkm &&
|
|
test_write_lines sub1 sub2 sub3 sub4 >chks &&
|
|
test_write_lines main-sub1 main-sub2 main-sub3 main-sub4 >chkms &&
|
|
sed "s,^,sub dir/," chkms >chkms_sub &&
|
|
|
|
# main-sub?? and /"sub dir"/main-sub?? both change, because those are the
|
|
# changes that were split into their own history. And "sub dir"/sub?? never
|
|
# change, since they were *only* changed in the subtree branch.
|
|
git log --name-only --pretty=format:"" >log &&
|
|
sort <log >sorted-log &&
|
|
sed "/^$/ d" sorted-log >actual &&
|
|
|
|
cat chkms chkm chks chkms_sub >expect-unsorted &&
|
|
sort expect-unsorted >expect &&
|
|
test_cmp expect actual
|
|
)
|
|
'
|
|
|
|
test_expect_success 'make sure the --rejoin commits never make it into subproj' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub3 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub3 &&
|
|
(
|
|
cd "$test_count/sub proj" &&
|
|
git fetch .. subproj-br &&
|
|
git merge FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub4 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub4 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
(
|
|
cd "$test_count/sub proj" &&
|
|
git fetch .. subproj-br &&
|
|
git merge FETCH_HEAD
|
|
) &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree pull --prefix="sub dir" ./"sub proj" HEAD &&
|
|
test "$(git log --pretty=format:"%s" HEAD^2 | grep -i split)" = ""
|
|
)
|
|
'
|
|
|
|
test_expect_success 'make sure no "git subtree" tagged commits make it into subproj' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub3 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub3 &&
|
|
(
|
|
cd "$test_count/sub proj" &&
|
|
git fetch .. subproj-br &&
|
|
git merge FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub4 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub4 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir" --annotate="*" --branch subproj-br --rejoin
|
|
) &&
|
|
(
|
|
cd "$test_count/sub proj" &&
|
|
git fetch .. subproj-br &&
|
|
git merge FETCH_HEAD
|
|
) &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree pull --prefix="sub dir" ./"sub proj" HEAD &&
|
|
|
|
# They are meaningless to subproj since one side of the merge refers to the mainline
|
|
test "$(git log --pretty=format:"%s%n%b" HEAD^2 | grep "git-subtree.*:")" = ""
|
|
)
|
|
'
|
|
|
|
#
|
|
# A new set of tests
|
|
#
|
|
|
|
test_expect_success 'make sure "git subtree split" find the correct parent' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git branch subproj-ref FETCH_HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir" --branch subproj-br &&
|
|
|
|
# at this point, the new commit parent should be subproj-ref, if it is
|
|
# not, something went wrong (the "newparent" of "HEAD~" commit should
|
|
# have been sub2, but it was not, because its cache was not set to
|
|
# itself)
|
|
test "$(git log --pretty=format:%P -1 subproj-br)" = "$(git rev-parse subproj-ref)"
|
|
)
|
|
'
|
|
|
|
test_expect_success 'split a new subtree without --onto option' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir" --branch subproj-br
|
|
) &&
|
|
mkdir "$test_count"/"sub dir2" &&
|
|
test_create_commit "$test_count" "sub dir2"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
|
|
# also test that we still can split out an entirely new subtree
|
|
# if the parent of the first commit in the tree is not empty,
|
|
# then the new subtree has accidentally been attached to something
|
|
git subtree split --prefix="sub dir2" --branch subproj2-br &&
|
|
test "$(git log --pretty=format:%P -1 subproj2-br)" = ""
|
|
)
|
|
'
|
|
|
|
test_expect_success 'verify one file change per commit' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git branch sub1 FETCH_HEAD &&
|
|
git subtree add --prefix="sub dir" sub1
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir" --branch subproj-br
|
|
) &&
|
|
mkdir "$test_count"/"sub dir2" &&
|
|
test_create_commit "$test_count" "sub dir2"/main-sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir2" --branch subproj2-br &&
|
|
|
|
git log --format="%H" >commit-list &&
|
|
while read commit
|
|
do
|
|
git log -n1 --format="" --name-only "$commit" >file-list &&
|
|
test_line_count -le 1 file-list || return 1
|
|
done <commit-list
|
|
)
|
|
'
|
|
|
|
test_expect_success 'push split to subproj' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub1 &&
|
|
test_create_commit "$test_count" main2 &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub2 &&
|
|
(
|
|
cd $test_count/"sub proj" &&
|
|
git branch sub-branch-1 &&
|
|
cd .. &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir"/main-sub3 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree push ./"sub proj" --prefix "sub dir" sub-branch-1 &&
|
|
cd ./"sub proj" &&
|
|
git checkout sub-branch-1 &&
|
|
test "$(last_commit_subject)" = "sub dir/main-sub3"
|
|
)
|
|
'
|
|
|
|
# --ignore-joins must ignore mainline content outside of the
|
|
# subtree. This test verifies that the logic in
|
|
# `find_existing_splits()` correctly handles a `git subtree add`
|
|
# In this test, the split history must not contain a commit titled
|
|
#
|
|
# Add 'sub/' from commit ...
|
|
#
|
|
# see: dd21d43b58 (subtree: make --ignore-joins pay
|
|
# attention to adds, 2018-09-28)
|
|
test_expect_success 'split --ignore-joins respects subtree add' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
(
|
|
cd "$test_count" &&
|
|
test_commit main_must_not_be_in_subtree &&
|
|
test_create_subtree_add . mksubtree sub sub1 &&
|
|
test_commit sub/sub2 &&
|
|
test_commit main_must_not_be_in_subtree2 &&
|
|
git subtree split --prefix sub -b first_split --rejoin &&
|
|
test_commit sub/sub3 &&
|
|
no_ignore_joins="$(git subtree split --prefix sub -b no_ignore_joins)" &&
|
|
ignore_joins="$(git subtree split --prefix sub --ignore-joins -b ignore_joins)" &&
|
|
git checkout ignore_joins &&
|
|
test_path_is_file sub1.t &&
|
|
test_path_is_file sub2.t &&
|
|
test_path_is_file sub3.t &&
|
|
! test_path_is_file main_must_not_be_in_subtree.t &&
|
|
! test_path_is_file main_must_not_be_in_subtree2.t &&
|
|
test -z "$(git log -1 --grep "Add '''sub/''' from commit" ignore_joins)" &&
|
|
test "$no_ignore_joins" = "$ignore_joins" &&
|
|
test "$(git rev-list --count ignore_joins)" -eq 3;
|
|
)
|
|
'
|
|
|
|
# split excludes commits reachable from any previous --rejoin.
|
|
# These ignored commits can still be the basis for new work
|
|
# after the --rejoin. These commits must be processed, even
|
|
# if they are excluded. Otherwise, the split history will be
|
|
# incorrect.
|
|
#
|
|
# here, the merge
|
|
#
|
|
# git merge --no-ff new_work_based_on_prejoin
|
|
#
|
|
# doesn't contain any subtree changes and so should not end
|
|
# up in the split history. this subtree should be flat,
|
|
# with no merges.
|
|
#
|
|
# see: 315a84f9aa (subtree: use commits before rejoins for
|
|
# splits, 2018-09-28)
|
|
test_expect_success 'split links out-of-tree pre --rejoin commits with post --rejoin commits' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
(
|
|
cd "$test_count" &&
|
|
test_commit main_must_not_be_in_subtree &&
|
|
mkdir sub &&
|
|
test_commit sub/sub1 &&
|
|
test_commit sub/sub2 &&
|
|
git subtree split --prefix sub --rejoin &&
|
|
test "$(git rev-list --count HEAD)" -eq 6 &&
|
|
git checkout sub/sub1 &&
|
|
git checkout -b new_work_based_on_prejoin &&
|
|
test_commit main_must_not_be_in_subtree2 &&
|
|
git checkout main &&
|
|
git merge --no-ff new_work_based_on_prejoin &&
|
|
test_commit sub/sub3 &&
|
|
git subtree split -d --prefix sub -b second_split &&
|
|
git checkout second_split &&
|
|
test_path_is_file sub1.t &&
|
|
test_path_is_file sub2.t &&
|
|
test_path_is_file sub3.t &&
|
|
! test_path_is_file main_must_not_be_in_subtree.t &&
|
|
! test_path_is_file main_must_not_be_in_subtree2.t &&
|
|
test "$(git rev-list --count --merges second_split)" -eq 0 &&
|
|
test "$(git rev-list --count second_split)" -eq 3;
|
|
)
|
|
'
|
|
|
|
# split must keep merge commits with unrelated histories, even
|
|
# if both parents are treesame. When deciding whether or not
|
|
# to eliminate a parent, copy_or_skip compares the merge-base
|
|
# of each parent.
|
|
#
|
|
# in the split_of_merges branch:
|
|
#
|
|
# * expect 4 commits
|
|
# * HEAD~ must be a merge
|
|
#
|
|
# see: 68f8ff8151 (subtree: improve decision on merges kept
|
|
# in split, 2018-09-28)
|
|
test_expect_success 'split preserves merges with unrelated history' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
(
|
|
cd "$test_count" &&
|
|
test_commit main_must_not_be_in_subtree &&
|
|
mkdir sub &&
|
|
test_commit sub/sub1 &&
|
|
git checkout --orphan new_history &&
|
|
git checkout sub/sub1 -- . &&
|
|
git add . &&
|
|
git commit -m "treesame history but not a merge-base" &&
|
|
git checkout main &&
|
|
git merge --allow-unrelated-histories --no-ff new_history &&
|
|
test "$(git rev-parse "HEAD^1^{tree}")" = "$(git rev-parse "HEAD^2^{tree}")" &&
|
|
test_commit sub/sub2 &&
|
|
git subtree split -d --prefix sub -b split_of_merges &&
|
|
test "$(git rev-list --count split_of_merges)" -eq 4 &&
|
|
test -n "$(git rev-list --merges HEAD~)";
|
|
)
|
|
'
|
|
|
|
#
|
|
# This test covers 2 cases in subtree split copy_or_skip code
|
|
# 1) Merges where one parent is a superset of the changes of the other
|
|
# parent regarding changes to the subtree, in this case the merge
|
|
# commit should be copied
|
|
# 2) Merges where only one parent operate on the subtree, and the merge
|
|
# commit should be skipped
|
|
#
|
|
# (1) is checked by ensuring subtree_tip is a descendent of subtree_branch
|
|
# (2) should have a check added (not_a_subtree_change shouldn't be present
|
|
# on the produced subtree)
|
|
#
|
|
# Other related cases which are not tested (or currently handled correctly)
|
|
# - Case (1) where there are more than 2 parents, it will sometimes correctly copy
|
|
# the merge, and sometimes not
|
|
# - Merge commit where both parents have same tree as the merge, currently
|
|
# will always be skipped, even if they reached that state via different
|
|
# set of commits.
|
|
#
|
|
|
|
test_expect_success 'subtree descendant check' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
test_create_commit "$test_count" folder_subtree/a &&
|
|
(
|
|
cd "$test_count" &&
|
|
git branch branch
|
|
) &&
|
|
test_create_commit "$test_count" folder_subtree/0 &&
|
|
test_create_commit "$test_count" folder_subtree/b &&
|
|
cherry=$(cd "$test_count" && git rev-parse HEAD) &&
|
|
(
|
|
cd "$test_count" &&
|
|
git checkout branch
|
|
) &&
|
|
test_create_commit "$test_count" commit_on_branch &&
|
|
(
|
|
cd "$test_count" &&
|
|
git cherry-pick $cherry &&
|
|
git checkout main &&
|
|
git merge -m "merge should be kept on subtree" branch &&
|
|
git branch no_subtree_work_branch
|
|
) &&
|
|
test_create_commit "$test_count" folder_subtree/d &&
|
|
(
|
|
cd "$test_count" &&
|
|
git checkout no_subtree_work_branch
|
|
) &&
|
|
test_create_commit "$test_count" not_a_subtree_change &&
|
|
(
|
|
cd "$test_count" &&
|
|
git checkout main &&
|
|
git merge -m "merge should be skipped on subtree" no_subtree_work_branch &&
|
|
|
|
git subtree split --prefix folder_subtree/ --branch subtree_tip main &&
|
|
git subtree split --prefix folder_subtree/ --branch subtree_branch branch &&
|
|
test $(git rev-list --count subtree_tip..subtree_branch) = 0
|
|
)
|
|
'
|
|
|
|
test_expect_success GPG 'add subproj with GPG signing using -S flag' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" -S FETCH_HEAD &&
|
|
git verify-commit HEAD &&
|
|
test "$(last_commit_subject)" = "Add '\''sub dir/'\'' from commit '\''$(git rev-parse FETCH_HEAD)'\''"
|
|
)
|
|
'
|
|
|
|
test_expect_success GPG 'add subproj with GPG signing using --gpg-sign flag' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" --gpg-sign FETCH_HEAD &&
|
|
git verify-commit HEAD &&
|
|
test "$(last_commit_subject)" = "Add '\''sub dir/'\'' from commit '\''$(git rev-parse FETCH_HEAD)'\''"
|
|
)
|
|
'
|
|
|
|
test_expect_success GPG 'add subproj with GPG signing using specific key ID' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" -S"$GIT_COMMITTER_EMAIL" FETCH_HEAD &&
|
|
git verify-commit HEAD &&
|
|
test "$(last_commit_subject)" = "Add '\''sub dir/'\'' from commit '\''$(git rev-parse FETCH_HEAD)'\''"
|
|
)
|
|
'
|
|
|
|
test_expect_success GPG 'merge with GPG signing' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree merge --prefix="sub dir" -S FETCH_HEAD &&
|
|
git verify-commit HEAD
|
|
)
|
|
'
|
|
|
|
test_expect_success GPG 'split with GPG signing and --rejoin' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" FETCH_HEAD
|
|
) &&
|
|
test_create_commit "$test_count" "sub dir/main-sub1" &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree split --prefix="sub dir" --rejoin -S &&
|
|
git verify-commit HEAD
|
|
)
|
|
'
|
|
|
|
test_expect_success GPG 'add with --squash and GPG signing' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git fetch ./"sub proj" HEAD &&
|
|
git subtree add --prefix="sub dir" --squash -S FETCH_HEAD &&
|
|
git verify-commit HEAD &&
|
|
# With --squash, the commit subject should reference the squash commit (first parent of merge)
|
|
squash_commit=$(git rev-parse HEAD^2) &&
|
|
test "$(last_commit_subject)" = "Merge commit '\''$squash_commit'\'' as '\''sub dir'\''"
|
|
)
|
|
'
|
|
|
|
test_expect_success GPG 'pull with GPG signing' '
|
|
subtree_test_create_repo "$test_count" &&
|
|
subtree_test_create_repo "$test_count/sub proj" &&
|
|
test_create_commit "$test_count" main1 &&
|
|
test_create_commit "$test_count/sub proj" sub1 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree add --prefix="sub dir" ./"sub proj" HEAD
|
|
) &&
|
|
test_create_commit "$test_count/sub proj" sub2 &&
|
|
(
|
|
cd "$test_count" &&
|
|
git subtree pull --prefix="sub dir" -S ./"sub proj" HEAD &&
|
|
git verify-commit HEAD
|
|
)
|
|
'
|
|
|
|
test_done
|