t/t3650-replay-basics.sh

#!/bin/sh

test_description='basic git replay tests'

GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME

. ./test-lib.sh

GIT_AUTHOR_NAME=author@name
GIT_AUTHOR_EMAIL=bogus@email@address
export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL

test_expect_success 'setup' '
	test_commit A &&
	test_commit B &&

	git switch -c topic1 &&
	test_commit C &&
	git switch -c topic2 &&
	test_commit D &&
	test_commit E &&
	git switch topic1 &&
	test_commit F &&
	git switch -c topic3 &&
	test_commit G &&
	test_commit H &&
	git switch -c empty &&
	git commit --allow-empty -m empty &&
	git switch -c topic4 main &&
	test_commit I &&
	test_commit J &&

	git switch -c next main &&
	test_commit K &&
	git merge -m "Merge topic1" topic1 &&
	git merge -m "Merge topic2" topic2 &&
	git merge -m "Merge topic3" topic3 &&
	>evil &&
	git add evil &&
	git commit --amend &&
	git merge -m "Merge topic4" topic4 &&

	git switch main &&
	test_commit L &&
	test_commit M &&

	git switch --detach topic4 &&
	test_commit N &&
	test_commit O &&
	git switch -c topic-with-merge topic4 &&
	test_merge P O --no-ff &&
	git switch main &&

	git switch --orphan unrelated &&
	test_commit unrelated-root &&

	git switch -c conflict B &&
	test_commit C.conflict C.t conflict &&
	git branch -D unrelated &&

	git switch -c divergent-x main &&
	test_commit X &&
	git switch -c divergent-y main &&
	test_commit Y &&
	git switch divergent-x &&
	test_merge Z divergent-y --no-ff
'

test_expect_success 'setup bare' '
	git clone --bare . bare
'

test_expect_success 'argument to --advance must be a reference' '
	echo "fatal: argument to --advance must be a reference" >expect &&
	oid=$(git rev-parse main) &&
	test_must_fail git replay --advance=$oid topic1..topic2 2>actual &&
	test_cmp expect actual
'

test_expect_success '--onto with invalid commit-ish' '
	printf "fatal: ${SQ}refs/not-valid${SQ} is not " >expect &&
	printf "a valid commit-ish for --onto\n" >>expect &&
	test_must_fail git replay --onto=refs/not-valid topic1..topic2 2>actual &&
	test_cmp expect actual
'

test_expect_success 'exactly one of --onto, --advance, or --revert is required' '
	echo "error: exactly one of --onto, --advance, or --revert is required" >expect &&
	test_might_fail git replay -h >>expect &&
	test_must_fail git replay topic1..topic2 2>actual &&
	test_cmp expect actual
'

test_expect_success 'replay down to root onto another branch' '
	git replay --ref-action=print --onto main topic2 >result &&

	test_line_count = 1 result &&

	git log --format=%s $(cut -f 3 -d " " result) >actual &&
	test_write_lines E D C M L B A >expect &&
	test_cmp expect actual
'

test_expect_success '--advance and --contained cannot be used together' '
	test_must_fail git replay --advance=main --contained \
		topic1..topic2 2>actual &&
	test_grep "cannot be used together" actual
'

test_expect_success 'cannot advance target ... ordering would be ill-defined' '
	echo "fatal: ${SQ}--advance${SQ} cannot be used with multiple revision ranges because the ordering would be ill-defined" >expect &&
	test_must_fail git replay --advance=main main topic1 topic2 2>actual &&
	test_cmp expect actual
'

test_expect_success 'replaying merge commits is not supported yet' '
	echo "fatal: replaying merge commits is not supported yet!" >expect &&
	test_must_fail git replay --advance=main main..topic-with-merge 2>actual &&
	test_cmp expect actual
'

test_expect_success 'using replay to rebase two branches, one on top of other' '
	git replay --ref-action=print --onto main topic1..topic2 >result &&

	test_line_count = 1 result &&

	git log --format=%s $(cut -f 3 -d " " result) >actual &&
	test_write_lines E D M L B A >expect &&
	test_cmp expect actual &&

	printf "update refs/heads/topic2 " >expect &&
	printf "%s " $(cut -f 3 -d " " result) >>expect &&
	git rev-parse topic2 >>expect &&

	test_cmp expect result
'

test_expect_success 'using replay on bare repo to rebase two branches, one on top of other' '
	git -C bare replay --ref-action=print --onto main topic1..topic2 >result-bare &&
	test_cmp expect result-bare
'

test_expect_success 'using replay to rebase with a conflict' '
	test_expect_code 1 git replay --onto topic1 B..conflict
'

test_expect_success 'using replay on bare repo to rebase with a conflict' '
	test_expect_code 1 git -C bare replay --onto topic1 B..conflict
'

test_expect_success 'using replay to perform basic cherry-pick' '
	# The differences between this test and previous ones are:
	#   --advance vs --onto
	# 2nd field of result is refs/heads/main vs. refs/heads/topic2
	# 4th field of result is hash for main instead of hash for topic2

	git replay --ref-action=print --advance main topic1..topic2 >result &&

	test_line_count = 1 result &&

	git log --format=%s $(cut -f 3 -d " " result) >actual &&
	test_write_lines E D M L B A >expect &&
	test_cmp expect actual &&

	printf "update refs/heads/main " >expect &&
	printf "%s " $(cut -f 3 -d " " result) >>expect &&
	git rev-parse main >>expect &&

	test_cmp expect result
'

test_expect_success 'using replay on bare repo to perform basic cherry-pick' '
	git -C bare replay --ref-action=print --advance main topic1..topic2 >result-bare &&
	test_cmp expect result-bare
'

test_expect_success 'commits that become empty are dropped' '
	# Save original branches
	git for-each-ref --format="update %(refname) %(objectname)" \
		refs/heads/ >original-branches &&
	test_when_finished "git update-ref --stdin <original-branches &&
		rm original-branches" &&
	# Cherry-pick tip of topic1 ("F"), from the middle of A..empty, to main
	git replay --advance main topic1^! &&

	# Replay all of A..empty onto main (which includes topic1 & thus F
	# in the middle)
	git replay --onto main --branches --ancestry-path=empty ^A \
		>result &&
	git log --format="%s%d" L..empty >actual &&
	test_write_lines >expect \
		"empty (empty)" "H (topic3)" G "C (topic1)" "F (main)" "M (tag: M)" &&
	test_cmp expect actual
'

test_expect_success 'replay on bare repo fails with both --advance and --onto' '
	test_must_fail git -C bare replay --advance main --onto main topic1..topic2 >result-bare
'

test_expect_success 'replay fails when both --advance and --onto are omitted' '
	test_must_fail git replay topic1..topic2 >result
'

test_expect_success 'using replay to also rebase a contained branch' '
	git replay --ref-action=print --contained --onto main main..topic3 >result &&

	test_line_count = 2 result &&
	cut -f 3 -d " " result >new-branch-tips &&

	git log --format=%s $(head -n 1 new-branch-tips) >actual &&
	test_write_lines F C M L B A >expect &&
	test_cmp expect actual &&

	git log --format=%s $(tail -n 1 new-branch-tips) >actual &&
	test_write_lines H G F C M L B A >expect &&
	test_cmp expect actual &&

	printf "update refs/heads/topic1 " >expect &&
	printf "%s " $(head -n 1 new-branch-tips) >>expect &&
	git rev-parse topic1 >>expect &&
	printf "update refs/heads/topic3 " >>expect &&
	printf "%s " $(tail -n 1 new-branch-tips) >>expect &&
	git rev-parse topic3 >>expect &&

	test_cmp expect result
'

test_expect_success 'using replay on bare repo to also rebase a contained branch' '
	git -C bare replay --ref-action=print --contained --onto main main..topic3 >result-bare &&
	test_cmp expect result-bare
'

test_expect_success 'using replay to rebase multiple divergent branches' '
	git replay --ref-action=print --onto main ^topic1 topic2 topic4 >result &&

	test_line_count = 2 result &&
	cut -f 3 -d " " result >new-branch-tips &&

	git log --format=%s $(head -n 1 new-branch-tips) >actual &&
	test_write_lines E D M L B A >expect &&
	test_cmp expect actual &&

	git log --format=%s $(tail -n 1 new-branch-tips) >actual &&
	test_write_lines J I M L B A >expect &&
	test_cmp expect actual &&

	printf "update refs/heads/topic2 " >expect &&
	printf "%s " $(head -n 1 new-branch-tips) >>expect &&
	git rev-parse topic2 >>expect &&
	printf "update refs/heads/topic4 " >>expect &&
	printf "%s " $(tail -n 1 new-branch-tips) >>expect &&
	git rev-parse topic4 >>expect &&

	test_cmp expect result
'

test_expect_success 'using replay on bare repo to rebase multiple divergent branches, including contained ones' '
	git -C bare replay --ref-action=print --contained --onto main ^main topic2 topic3 topic4 >result &&

	test_line_count = 4 result &&
	cut -f 3 -d " " result >new-branch-tips &&

	>expect &&
	for i in 2 1 3 4
	do
		printf "update refs/heads/topic$i " >>expect &&
		printf "%s " $(grep topic$i result | cut -f 3 -d " ") >>expect &&
		git -C bare rev-parse topic$i >>expect || return 1
	done &&

	test_cmp expect result &&

	test_write_lines F C M L B A >expect1 &&
	test_write_lines E D C M L B A >expect2 &&
	test_write_lines H G F C M L B A >expect3 &&
	test_write_lines J I M L B A >expect4 &&

	for i in 1 2 3 4
	do
		git -C bare log --format=%s $(grep topic$i result | cut -f 3 -d " ") >actual &&
		test_cmp expect$i actual || return 1
	done
'

test_expect_success 'using replay to update detached HEAD' '
	current_head=$(git branch --show-current) &&
	test_when_finished git switch "$current_head" &&
	git switch --detach &&
	test_commit something &&
	git replay --ref-action=print --onto HEAD~2 --ref-action=print HEAD~..HEAD >updates &&
	test_grep "update HEAD " updates
'

test_expect_success 'merge.directoryRenames=false' '
	# create a test case that stress-tests the rename caching
	git switch -c rename-onto &&

	mkdir -p to-rename &&
	test_commit to-rename/move &&

	mkdir -p renamed-directory &&
	git mv to-rename/move* renamed-directory/ &&
	test_tick &&
	git commit -m renamed-directory &&

	git switch -c rename-from HEAD^ &&
	test_commit to-rename/add-a-file &&
	echo modified >to-rename/add-a-file.t &&
	test_tick &&
	git commit -m modified to-rename/add-a-file.t &&

	git -c merge.directoryRenames=false replay \
		--onto rename-onto rename-onto..rename-from
'

test_expect_success 'default atomic behavior updates refs directly' '
	# Use a separate branch to avoid contaminating topic2 for later tests
	git branch test-atomic topic2 &&
	test_when_finished "git branch -D test-atomic" &&

	# Test default atomic behavior (no output, refs updated)
	git replay --onto main topic1..test-atomic >output &&
	test_must_be_empty output &&

	# Verify ref was updated
	git log --format=%s test-atomic >actual &&
	test_write_lines E D M L B A >expect &&
	test_cmp expect actual &&

	# Verify reflog message includes SHA of onto commit
	git reflog test-atomic -1 --format=%gs >reflog-msg &&
	ONTO_SHA=$(git rev-parse main) &&
	echo "replay --onto $ONTO_SHA" >expect-reflog &&
	test_cmp expect-reflog reflog-msg
'

test_expect_success 'atomic behavior in bare repository' '
	# Store original state for cleanup
	START=$(git -C bare rev-parse topic2) &&
	test_when_finished "git -C bare update-ref refs/heads/topic2 $START" &&

	# Test atomic updates work in bare repo
	git -C bare replay --onto main topic1..topic2 >output &&
	test_must_be_empty output &&

	# Verify ref was updated in bare repo
	git -C bare log --format=%s topic2 >actual &&
	test_write_lines E D M L B A >expect &&
	test_cmp expect actual
'

test_expect_success 'reflog message for --advance mode' '
	# Store original state
	START=$(git rev-parse main) &&
	test_when_finished "git update-ref refs/heads/main $START" &&

	# Test --advance mode reflog message
	git replay --advance main topic1..topic2 >output &&
	test_must_be_empty output &&

	# Verify reflog message includes --advance and branch name
	git reflog main -1 --format=%gs >reflog-msg &&
	echo "replay --advance main" >expect-reflog &&
	test_cmp expect-reflog reflog-msg
'

test_expect_success 'replay.refAction=print config option' '
	# Store original state
	START=$(git rev-parse topic2) &&
	test_when_finished "git branch -f topic2 $START" &&

	# Test with config set to print
	test_config replay.refAction print &&
	git replay --onto main topic1..topic2 >output &&
	test_line_count = 1 output &&
	test_grep "^update refs/heads/topic2 " output
'

test_expect_success 'replay.refAction=update config option' '
	# Store original state
	START=$(git rev-parse topic2) &&
	test_when_finished "git branch -f topic2 $START" &&

	# Test with config set to update
	test_config replay.refAction update &&
	git replay --onto main topic1..topic2 >output &&
	test_must_be_empty output &&

	# Verify ref was updated
	git log --format=%s topic2 >actual &&
	test_write_lines E D M L B A >expect &&
	test_cmp expect actual
'

test_expect_success 'command-line --ref-action overrides config' '
	# Store original state
	START=$(git rev-parse topic2) &&
	test_when_finished "git branch -f topic2 $START" &&

	# Set config to update but use --ref-action=print
	test_config replay.refAction update &&
	git replay --ref-action=print --onto main topic1..topic2 >output &&
	test_line_count = 1 output &&
	test_grep "^update refs/heads/topic2 " output
'

test_expect_success 'invalid replay.refAction value' '
	test_config replay.refAction invalid &&
	test_must_fail git replay --onto main topic1..topic2 2>error &&
	test_grep "invalid.*replay.refAction.*value" error
'

test_expect_success 'argument to --revert must be a reference' '
	echo "fatal: argument to --revert must be a reference" >expect &&
	oid=$(git rev-parse main) &&
	test_must_fail git replay --revert=$oid topic1..topic2 2>actual &&
	test_cmp expect actual
'

test_expect_success 'cannot revert with multiple sources' '
	echo "fatal: ${SQ}--revert${SQ} cannot be used with multiple revision ranges because the ordering would be ill-defined" >expect &&
	test_must_fail git replay --revert main main topic1 topic2 2>actual &&
	test_cmp expect actual
'

test_expect_success 'using replay --revert to revert commits' '
	# Reuse existing topic4 branch (has commits I and J on top of main)
	START=$(git rev-parse topic4) &&
	test_when_finished "git branch -f topic4 $START" &&

	# Revert commits I and J
	git replay --revert topic4 topic4~2..topic4 &&

	# Verify the revert commits were created (newest-first ordering
	# means J is reverted first, then I on top)
	git log --format=%s -4 topic4 >actual &&
	cat >expect <<-\EOF &&
	Revert "I"
	Revert "J"
	J
	I
	EOF
	test_cmp expect actual &&

	# Verify commit message format includes hash (tip is Revert "I")
	test_commit_message topic4 <<-EOF &&
	Revert "I"

	This reverts commit $(git rev-parse I).
	EOF

	# Verify reflog message
	git reflog topic4 -1 --format=%gs >reflog-msg &&
	echo "replay --revert topic4" >expect-reflog &&
	test_cmp expect-reflog reflog-msg
'

test_expect_success 'using replay --revert in bare repo' '
	# Reuse existing topic4 in bare repo
	START=$(git -C bare rev-parse topic4) &&
	test_when_finished "git -C bare update-ref refs/heads/topic4 $START" &&

	# Revert commit J in bare repo
	git -C bare replay --revert topic4 topic4~1..topic4 &&

	# Verify revert was created
	git -C bare log -1 --format=%s topic4 >actual &&
	echo "Revert \"J\"" >expect &&
	test_cmp expect actual
'

test_expect_success 'revert of revert uses Reapply' '
	# Use topic4 and first revert J, then revert the revert
	START=$(git rev-parse topic4) &&
	test_when_finished "git branch -f topic4 $START" &&

	# First revert J
	git replay --revert topic4 topic4~1..topic4 &&
	REVERT_J=$(git rev-parse topic4) &&

	# Now revert the revert - should become Reapply
	git replay --revert topic4 topic4~1..topic4 &&

	# Verify Reapply prefix and message format
	test_commit_message topic4 <<-EOF
	Reapply "J"

	This reverts commit $REVERT_J.
	EOF
'

test_expect_success 'git replay --revert with conflict' '
	# conflict branch has C.conflict which conflicts with topic1s C
	test_expect_code 1 git replay --revert conflict B..topic1
'

test_expect_success 'git replay --revert incompatible with --contained' '
	test_must_fail git replay --revert topic4 --contained topic4~1..topic4 2>error &&
	test_grep "cannot be used together" error
'

test_expect_success 'git replay --revert incompatible with --onto' '
	test_must_fail git replay --revert topic4 --onto main topic4~1..topic4 2>error &&
	test_grep "cannot be used together" error
'

test_expect_success 'git replay --revert incompatible with --advance' '
	test_must_fail git replay --revert topic4 --advance main topic4~1..topic4 2>error &&
	test_grep "cannot be used together" error
'

test_expect_success 'using --onto with --ref' '
	git branch test-ref-onto topic2 &&
	test_when_finished "git branch -D test-ref-onto" &&

	git replay --ref-action=print --onto=main --ref=refs/heads/test-ref-onto topic1..topic2 >result &&

	test_line_count = 1 result &&
	test_grep "^update refs/heads/test-ref-onto " result &&

	git log --format=%s $(cut -f 3 -d " " result) >actual &&
	test_write_lines E D M L B A >expect &&
	test_cmp expect actual
'

test_expect_success 'using --advance with --ref' '
	git branch test-ref-advance main &&
	git branch test-ref-target main &&
	test_when_finished "git branch -D test-ref-advance test-ref-target" &&

	git replay --ref-action=print --advance=test-ref-advance --ref=refs/heads/test-ref-target topic1..topic2 >result &&

	test_line_count = 1 result &&
	test_grep "^update refs/heads/test-ref-target " result
'

test_expect_success 'using --revert with --ref' '
	git branch test-ref-revert topic4 &&
	git branch test-ref-revert-target topic4 &&
	test_when_finished "git branch -D test-ref-revert test-ref-revert-target" &&

	git replay --ref-action=print --revert=test-ref-revert --ref=refs/heads/test-ref-revert-target topic4~1..topic4 >result &&

	test_line_count = 1 result &&
	test_grep "^update refs/heads/test-ref-revert-target " result
'

test_expect_success '--ref is incompatible with --contained' '
	test_must_fail git replay --onto=main --ref=refs/heads/main --contained topic1..topic2 2>err &&
	test_grep "cannot be used together" err
'

test_expect_success '--ref with nonexistent fully-qualified ref' '
	test_when_finished "git update-ref -d refs/heads/new-branch" &&

	git replay --onto=main --ref=refs/heads/new-branch topic1..topic2 &&

	git log --format=%s -2 new-branch >actual &&
	test_write_lines E D >expect &&
	test_cmp expect actual
'

test_expect_success '--ref must be a valid refname' '
	test_must_fail git replay --onto=main --ref="refs/heads/bad..ref" topic1..topic2 2>err &&
	test_grep "is not a valid refname" err
'

test_expect_success '--ref requires fully qualified ref' '
	test_must_fail git replay --onto=main --ref=main topic1..topic2 2>err &&
	test_grep "is not a valid refname" err
'

test_expect_success '--onto with --ref rejects multiple revision ranges' '
	test_must_fail git replay --onto=main --ref=refs/heads/topic2 ^topic1 topic2 topic4 2>err &&
	test_grep "cannot be used with multiple revision ranges" err
'

test_expect_success 'replay to rebase merge commit with --linearize' '
	git replay --ref-action=print --linearize \
		--onto main I..topic-with-merge >result &&

	test_line_count = 1 result &&

	git log --format=%s $(cut -f 3 -d " " result) >actual &&
	test_write_lines O N J M L B A >expect &&
	test_cmp expect actual
'

test_expect_success 'replay to rebase merge commit with --linearize down to the root commit' '
	git replay --ref-action=print --linearize \
		--onto unrelated-root topic-with-merge >result &&

	test_line_count = 1 result &&

	git log --format=%s $(cut -f 3 -d " " result) >actual &&
	test_write_lines O N J I B A unrelated-root >expect &&
	test_cmp expect actual
'

test_expect_success 'replay to cherry-pick merge commit with --linearize' '
	git replay --ref-action=print --linearize \
		--advance main I..topic-with-merge >result &&

	test_line_count = 1 result &&

	git log --format=%s $(cut -f 3 -d " " result) >actual &&
	test_write_lines O N J M L B A >expect &&
	test_cmp expect actual &&

	printf "update refs/heads/main " >expect &&
	printf "%s " $(cut -f 3 -d " " result) >>expect &&
	git rev-parse main >>expect &&
	test_cmp expect result
'

test_expect_success 'replay --linearize produces the same patches' '
	git replay --ref-action=print --linearize \
		--onto main I..topic-with-merge >result &&

	test_line_count = 1 result &&
	tip=$(cut -f 3 -d " " result) &&

	# range-diff does not care about the dropped merge,
	# so the original commits (I..topic-with-merge)
	# and the replayed chain (main..tip) must produce identical patches.
	git range-diff I..topic-with-merge main..$tip >out &&
	test_file_not_empty out &&
	test_grep ! -v "=" out &&

	git log --oneline main..$tip >out &&
	test_line_count = 3 out
'

test_expect_success '--linearize rejects multiple branches' '
	test_must_fail git replay --ref-action=print --linearize \
		--onto main ^B topic2 topic3 topic4 2>err &&
	test_grep "cannot be used with multiple branches" err
'

test_expect_success 'replay with --linearize of a divergent merge keeps both sides' '
	git replay --ref-action=print --linearize \
		--onto main main..divergent-x >result &&
	test_line_count = 1 result &&
	tip=$(cut -f 3 -d " " result) &&

	# The merge Z is dropped, but both X and Y are linearized onto main;
	# neither side is lost.
	git log --format=%s main..$tip >actual &&
	test_write_lines Y X >expect &&
	test_cmp expect actual
'

test_expect_success '--linearize and --contained cannot be used together' '
	test_must_fail git replay --ref-action=print --linearize --contained \
		--onto main ^B topic-with-merge 2>err &&
	test_grep "cannot be used together" err
'

test_expect_success 'replay --revert with --linearize reverts a range containing a merge' '
	git replay --ref-action=print --revert=divergent-x --linearize \
		main..divergent-x >result &&
	test_line_count = 1 result &&
	tip=$(cut -f 3 -d " " result) &&

	git log --format=%s $tip >actual &&
	test_write_lines \
		"Revert \"X\"" "Revert \"Y\"" Z Y X M L B A >expect &&
	test_cmp expect actual &&

	test_must_fail git cat-file -e $tip:X.t &&
	test_must_fail git cat-file -e $tip:Y.t
'

test_expect_success 'replay fails without segfault when objects are missing' '
	test_when_finished "rm -fr unreadable" &&
	git init unreadable &&
	(
		cd unreadable &&

		test_write_lines l1 l2 l3 l4 l5 l6 l7 l8 >f &&
		git add f &&
		git commit -m base &&
		git branch base &&

		test_write_lines l1 l2 l3 l4 l5 l6 l7 CHANGED >f &&
		git commit -am side &&
		git branch side &&

		git switch -c onto base &&
		test_write_lines CHANGED l2 l3 l4 l5 l6 l7 l8 >f &&
		git commit -am onto &&

		# The replay works while every object is readable.
		git replay --onto onto base..side &&

		# Removing the onto tree makes parse_tree() fail during the
		# incore merge, driving clean < 0 with a NULL result tree.
		onto_tree=$(git rev-parse onto^{tree}) &&
		obj=$(test_oid_to_path "$onto_tree") &&
		mv .git/objects/${obj} saved-tree &&

		# Ensure replay gracefully handles the missing object
		test_must_fail git replay --onto onto base..side 2>err &&
		test_grep -e "Could not read" -e "collecting merge info failed" err
	)
'

test_done