git/t/t5574-fetch-output.sh

#!/bin/sh

test_description='git fetch output format'

GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME

TEST_PASSES_SANITIZE_LEAK=true
. ./test-lib.sh

test_expect_success 'fetch with invalid output format configuration' '
	test_when_finished "rm -rf clone" &&
	git clone . clone &&

	test_must_fail git -C clone -c fetch.output fetch origin 2>actual.err &&
	cat >expect <<-EOF &&
	error: missing value for ${SQ}fetch.output${SQ}
	fatal: unable to parse ${SQ}fetch.output${SQ} from command-line config
	EOF
	test_cmp expect actual.err &&

	test_must_fail git -C clone -c fetch.output= fetch origin 2>actual.err &&
	cat >expect <<-EOF &&
	fatal: invalid value for ${SQ}fetch.output${SQ}: ${SQ}${SQ}
	EOF
	test_cmp expect actual.err &&

	test_must_fail git -C clone -c fetch.output=garbage fetch origin 2>actual.err &&
	cat >expect <<-EOF &&
	fatal: invalid value for ${SQ}fetch.output${SQ}: ${SQ}garbage${SQ}
	EOF
	test_cmp expect actual.err
'

test_expect_success 'fetch aligned output' '
	git clone . full-output &&
	test_commit looooooooooooong-tag &&
	(
		cd full-output &&
		git -c fetch.output=full fetch origin >actual 2>&1 &&
		grep -e "->" actual | cut -c 22- >../actual
	) &&
	cat >expect <<-\EOF &&
	main                 -> origin/main
	looooooooooooong-tag -> looooooooooooong-tag
	EOF
	test_cmp expect actual
'

test_expect_success 'fetch compact output' '
	git clone . compact &&
	test_commit extraaa &&
	(
		cd compact &&
		git -c fetch.output=compact fetch origin >actual 2>&1 &&
		grep -e "->" actual | cut -c 22- >../actual
	) &&
	cat >expect <<-\EOF &&
	main       -> origin/*
	extraaa    -> *
	EOF
	test_cmp expect actual
'

test_expect_success 'setup for fetch porcelain output' '
	# Set up a bunch of references that we can use to demonstrate different
	# kinds of flag symbols in the output format.
	test_commit commit-for-porcelain-output &&
	MAIN_OLD=$(git rev-parse HEAD) &&
	git branch "fast-forward" &&
	git branch "deleted-branch" &&
	git checkout -b force-updated &&
	test_commit --no-tag force-update-old &&
	FORCE_UPDATED_OLD=$(git rev-parse HEAD) &&
	git checkout main &&

	# Backup to preseed.git
	git clone --mirror . preseed.git &&

	# Continue changing our local references.
	git branch new-branch &&
	git branch -d deleted-branch &&
	git checkout fast-forward &&
	test_commit --no-tag fast-forward-new &&
	FAST_FORWARD_NEW=$(git rev-parse HEAD) &&
	git checkout force-updated &&
	git reset --hard HEAD~ &&
	test_commit --no-tag force-update-new &&
	FORCE_UPDATED_NEW=$(git rev-parse HEAD)
'

for opt in "" "--atomic"
do
	test_expect_success "fetch porcelain output ${opt:+(atomic)}" '
		test_when_finished "rm -rf porcelain" &&

		# Clone and pre-seed the repositories. We fetch references into two
		# namespaces so that we can test that rejected and force-updated
		# references are reported properly.
		refspecs="refs/heads/*:refs/unforced/* +refs/heads/*:refs/forced/*" &&
		git clone preseed.git porcelain &&
		git -C porcelain fetch origin $opt $refspecs &&

		cat >expect <<-EOF &&
		- $MAIN_OLD $ZERO_OID refs/forced/deleted-branch
		- $MAIN_OLD $ZERO_OID refs/unforced/deleted-branch
		  $MAIN_OLD $FAST_FORWARD_NEW refs/unforced/fast-forward
		! $FORCE_UPDATED_OLD $FORCE_UPDATED_NEW refs/unforced/force-updated
		* $ZERO_OID $MAIN_OLD refs/unforced/new-branch
		  $MAIN_OLD $FAST_FORWARD_NEW refs/forced/fast-forward
		+ $FORCE_UPDATED_OLD $FORCE_UPDATED_NEW refs/forced/force-updated
		* $ZERO_OID $MAIN_OLD refs/forced/new-branch
		  $MAIN_OLD $FAST_FORWARD_NEW refs/remotes/origin/fast-forward
		+ $FORCE_UPDATED_OLD $FORCE_UPDATED_NEW refs/remotes/origin/force-updated
		* $ZERO_OID $MAIN_OLD refs/remotes/origin/new-branch
		EOF

		# Change the URL of the repository to fetch different references.
		git -C porcelain remote set-url origin .. &&

		# Execute a dry-run fetch first. We do this to assert that the dry-run
		# and non-dry-run fetches produces the same output. Execution of the
		# fetch is expected to fail as we have a rejected reference update.
		test_must_fail git -C porcelain fetch $opt \
			--porcelain --dry-run --prune origin $refspecs >actual &&
		test_cmp expect actual &&

		# And now we perform a non-dry-run fetch.
		test_must_fail git -C porcelain fetch $opt \
			--porcelain --prune origin $refspecs >actual 2>stderr &&
		test_cmp expect actual &&
		test_must_be_empty stderr
	'
done

test_expect_success 'fetch porcelain with multiple remotes' '
	test_when_finished "rm -rf porcelain" &&

	git switch --create multiple-remotes &&
	git clone . porcelain &&
	git -C porcelain remote add second-remote "$PWD" &&
	git -C porcelain fetch second-remote &&

	test_commit --no-tag multi-commit &&
	old_commit=$(git rev-parse HEAD~) &&
	new_commit=$(git rev-parse HEAD) &&

	cat >expect <<-EOF &&
	  $old_commit $new_commit refs/remotes/origin/multiple-remotes
	  $old_commit $new_commit refs/remotes/second-remote/multiple-remotes
	EOF

	git -C porcelain fetch --porcelain --all >actual 2>stderr &&
	test_cmp expect actual &&
	test_must_be_empty stderr
'

test_expect_success 'fetch porcelain refuses to work with submodules' '
	test_when_finished "rm -rf porcelain" &&

	cat >expect <<-EOF &&
	fatal: options ${SQ}--porcelain${SQ} and ${SQ}--recurse-submodules${SQ} cannot be used together
	EOF

	git init porcelain &&
	test_must_fail git -C porcelain fetch --porcelain --recurse-submodules=yes 2>stderr &&
	test_cmp expect stderr &&

	test_must_fail git -C porcelain fetch --porcelain --recurse-submodules=on-demand 2>stderr &&
	test_cmp expect stderr
'

test_expect_success 'fetch porcelain overrides fetch.output config' '
	test_when_finished "rm -rf porcelain" &&

	git switch --create config-override &&
	git clone . porcelain &&
	test_commit new-commit &&
	old_commit=$(git rev-parse HEAD~) &&
	new_commit=$(git rev-parse HEAD) &&

	cat >expect <<-EOF &&
	  $old_commit $new_commit refs/remotes/origin/config-override
	* $ZERO_OID $new_commit refs/tags/new-commit
	EOF

	git -C porcelain -c fetch.output=compact fetch --porcelain >stdout 2>stderr &&
	test_must_be_empty stderr &&
	test_cmp expect stdout
'

test_expect_success 'fetch --no-porcelain overrides previous --porcelain' '
	test_when_finished "rm -rf no-porcelain" &&

	git switch --create no-porcelain &&
	git clone . no-porcelain &&
	test_commit --no-tag no-porcelain &&
	old_commit=$(git rev-parse --short HEAD~) &&
	new_commit=$(git rev-parse --short HEAD) &&

	cat >expect <<-EOF &&
	From $(test-tool path-utils real_path .)/.
	   $old_commit..$new_commit  no-porcelain -> origin/no-porcelain
	EOF

	git -C no-porcelain fetch --porcelain --no-porcelain >stdout 2>stderr &&
	test_cmp expect stderr &&
	test_must_be_empty stdout
'

test_expect_success 'fetch output with HEAD' '
	test_when_finished "rm -rf head" &&
	git clone . head &&

	git -C head fetch --dry-run origin HEAD >actual.out 2>actual.err &&
	cat >expect <<-EOF &&
	From $(test-tool path-utils real_path .)/.
	 * branch            HEAD       -> FETCH_HEAD
	EOF
	test_must_be_empty actual.out &&
	test_cmp expect actual.err &&

	git -C head fetch origin HEAD >actual.out 2>actual.err &&
	test_must_be_empty actual.out &&
	test_cmp expect actual.err &&

	git -C head fetch --dry-run origin HEAD:foo >actual.out 2>actual.err &&
	cat >expect <<-EOF &&
	From $(test-tool path-utils real_path .)/.
	 * [new ref]         HEAD       -> foo
	EOF
	test_must_be_empty actual.out &&
	test_cmp expect actual.err &&

	git -C head fetch origin HEAD:foo >actual.out 2>actual.err &&
	test_must_be_empty actual.out &&
	test_cmp expect actual.err
'

test_expect_success 'fetch porcelain output with HEAD' '
	test_when_finished "rm -rf head" &&
	git clone . head &&
	COMMIT_ID=$(git rev-parse HEAD) &&

	git -C head fetch --porcelain --dry-run origin HEAD >actual &&
	cat >expect <<-EOF &&
	* $ZERO_OID $COMMIT_ID FETCH_HEAD
	EOF
	test_cmp expect actual &&

	git -C head fetch --porcelain origin HEAD >actual &&
	test_cmp expect actual &&

	git -C head fetch --porcelain --dry-run origin HEAD:foo >actual &&
	cat >expect <<-EOF &&
	* $ZERO_OID $COMMIT_ID refs/heads/foo
	EOF
	test_cmp expect actual &&

	git -C head fetch --porcelain origin HEAD:foo >actual &&
	test_cmp expect actual
'

test_expect_success 'fetch output with object ID' '
	test_when_finished "rm -rf object-id" &&
	git clone . object-id &&
	commit=$(git rev-parse HEAD) &&

	git -C object-id fetch --dry-run origin $commit:object-id >actual.out 2>actual.err &&
	cat >expect <<-EOF &&
	From $(test-tool path-utils real_path .)/.
	 * [new ref]         $commit -> object-id
	EOF
	test_must_be_empty actual.out &&
	test_cmp expect actual.err &&

	git -C object-id fetch origin $commit:object-id >actual.out 2>actual.err &&
	test_must_be_empty actual.out &&
	test_cmp expect actual.err
'

test_expect_success '--no-show-forced-updates' '
	mkdir forced-updates &&
	(
		cd forced-updates &&
		git init &&
		test_commit 1 &&
		test_commit 2
	) &&
	git clone forced-updates forced-update-clone &&
	git clone forced-updates no-forced-update-clone &&
	git -C forced-updates reset --hard HEAD~1 &&
	(
		cd forced-update-clone &&
		git fetch --show-forced-updates origin 2>output &&
		test_grep "(forced update)" output
	) &&
	(
		cd no-forced-update-clone &&
		git fetch --no-show-forced-updates origin 2>output &&
		test_grep ! "(forced update)" output
	)
'

test_done