[thirdparty/git.git] / t / t5000-tar-tree.sh

#!/bin/sh
#
# Copyright (C) 2005 Rene Scharfe
#

test_description='git archive and git get-tar-commit-id test

This test covers the topics of file contents, commit date handling and
commit id embedding:

  The contents of the repository is compared to the extracted tar
  archive.  The repository contains simple text files, symlinks and a
  binary file (/bin/sh).  Only paths shorter than 99 characters are
  used.

  git archive applies the commit date to every file in the archive it
  creates.  The test sets the commit date to a specific value and checks
  if the tar archive contains that value.

  When giving git archive a commit id (in contrast to a tree id) it
  embeds this commit id into the tar archive as a comment.  The test
  checks the ability of git get-tar-commit-id to figure it out from the
  tar file.

'

. ./test-lib.sh

SUBSTFORMAT=%H%n

test_lazy_prereq TAR_NEEDS_PAX_FALLBACK '
	(
		mkdir pax &&
		cd pax &&
		"$TAR" xf "$TEST_DIRECTORY"/t5000/pax.tar &&
		test -f PaxHeaders.1791/file
	)
'

test_lazy_prereq GZIP 'gzip --version'

get_pax_header() {
	file=$1
	header=$2=

	while read len rest
	do
		if test "$len" = $(echo "$len $rest" | wc -c)
		then
			case "$rest" in
			$header*)
				echo "${rest#$header}"
				;;
			esac
		fi
	done <"$file"
}

check_tar() {
	tarfile=$1.tar
	listfile=$1.lst
	dir=$1
	dir_with_prefix=$dir/$2

	test_expect_success ' extract tar archive' '
		(mkdir $dir && cd $dir && "$TAR" xf -) <$tarfile
	'

	test_expect_success TAR_NEEDS_PAX_FALLBACK ' interpret pax headers' '
		(
			cd $dir &&
			for header in *.paxheader
			do
				data=${header%.paxheader}.data &&
				if test -h $data || test -e $data
				then
					path=$(get_pax_header $header path) &&
					if test -n "$path"
					then
						mv "$data" "$path"
					fi
				fi
			done
		)
	'

	test_expect_success ' validate filenames' '
		(cd ${dir_with_prefix}a && find .) | sort >$listfile &&
		test_cmp a.lst $listfile
	'

	test_expect_success ' validate file contents' '
		diff -r a ${dir_with_prefix}a
	'
}

check_added() {
	dir=$1
	path_in_fs=$2
	path_in_archive=$3

	test_expect_success " validate extra file $path_in_archive" '
		diff -r $path_in_fs $dir/$path_in_archive
	'
}

test_expect_success 'setup' '
	test_oid_cache <<-EOF
	obj sha1:19f9c8273ec45a8938e6999cb59b3ff66739902a
	obj sha256:3c666f798798601571f5cec0adb57ce4aba8546875e7693177e0535f34d2c49b
	EOF
'

test_expect_success \
    'populate workdir' \
    'mkdir a &&
     echo simple textfile >a/a &&
     ten=0123456789 && hundred=$ten$ten$ten$ten$ten$ten$ten$ten$ten$ten &&
     echo long filename >a/four$hundred &&
     mkdir a/bin &&
     test-tool genrandom "frotz" 500000 >a/bin/sh &&
     printf "A\$Format:%s\$O" "$SUBSTFORMAT" >a/substfile1 &&
     printf "A not substituted O" >a/substfile2 &&
     if test_have_prereq SYMLINKS; then
	ln -s a a/l1
     else
	printf %s a > a/l1
     fi &&
     (p=long_path_to_a_file && cd a &&
      for depth in 1 2 3 4 5; do mkdir $p && cd $p; done &&
      echo text >file_with_long_path) &&
     (cd a && find .) | sort >a.lst'

test_expect_success \
    'add ignored file' \
    'echo ignore me >a/ignored &&
     echo ignored export-ignore >.git/info/attributes'

test_expect_success 'add files to repository' '
	git add a &&
	GIT_COMMITTER_DATE="2005-05-27 22:00" git commit -m initial
'

test_expect_success 'setup export-subst' '
	echo "substfile?" export-subst >>.git/info/attributes &&
	git log --max-count=1 "--pretty=format:A${SUBSTFORMAT}O" HEAD \
		>a/substfile1
'

test_expect_success \
    'create bare clone' \
    'git clone --bare . bare.git &&
     cp .git/info/attributes bare.git/info/attributes'

test_expect_success \
    'remove ignored file' \
    'rm a/ignored'

test_expect_success \
    'git archive' \
    'git archive HEAD >b.tar'

check_tar b

test_expect_success 'git archive --prefix=prefix/' '
	git archive --prefix=prefix/ HEAD >with_prefix.tar
'

check_tar with_prefix prefix/

test_expect_success 'git-archive --prefix=olde-' '
	git archive --prefix=olde- HEAD >with_olde-prefix.tar
'

check_tar with_olde-prefix olde-

test_expect_success 'git archive --add-file' '
	echo untracked >untracked &&
	git archive --add-file=untracked HEAD >with_untracked.tar
'

check_tar with_untracked
check_added with_untracked untracked untracked

test_expect_success 'git archive --add-file twice' '
	echo untracked >untracked &&
	git archive --prefix=one/ --add-file=untracked \
		--prefix=two/ --add-file=untracked \
		--prefix= HEAD >with_untracked2.tar
'

check_tar with_untracked2
check_added with_untracked2 untracked one/untracked
check_added with_untracked2 untracked two/untracked

test_expect_success 'git archive on large files' '
    test_config core.bigfilethreshold 1 &&
    git archive HEAD >b3.tar &&
    test_cmp_bin b.tar b3.tar
'

test_expect_success \
    'git archive in a bare repo' \
    '(cd bare.git && git archive HEAD) >b3.tar'

test_expect_success \
    'git archive vs. the same in a bare repo' \
    'test_cmp_bin b.tar b3.tar'

test_expect_success 'git archive with --output' \
    'git archive --output=b4.tar HEAD &&
    test_cmp_bin b.tar b4.tar'

test_expect_success 'git archive --remote' \
    'git archive --remote=. HEAD >b5.tar &&
    test_cmp_bin b.tar b5.tar'

test_expect_success 'git archive --remote with configured remote' '
	git config remote.foo.url . &&
	(
		cd a &&
		git archive --remote=foo --output=../b5-nick.tar HEAD
	) &&
	test_cmp_bin b.tar b5-nick.tar
'

test_expect_success \
    'validate file modification time' \
    'mkdir extract &&
     "$TAR" xf b.tar -C extract a/a &&
     test-tool chmtime --get extract/a/a >b.mtime &&
     echo "1117231200" >expected.mtime &&
     test_cmp expected.mtime b.mtime'

test_expect_success \
    'git get-tar-commit-id' \
    'git get-tar-commit-id <b.tar >b.commitid &&
     test_cmp .git/$(git symbolic-ref HEAD) b.commitid'

test_expect_success 'git archive with --output, override inferred format' '
	git archive --format=tar --output=d4.zip HEAD &&
	test_cmp_bin b.tar d4.zip
'

test_expect_success GZIP 'git archive with --output and --remote creates .tgz' '
	git archive --output=d5.tgz --remote=. HEAD &&
	gzip -d -c <d5.tgz >d5.tar &&
	test_cmp_bin b.tar d5.tar
'

test_expect_success 'git archive --list outside of a git repo' '
	nongit git archive --list
'

test_expect_success 'git archive --remote outside of a git repo' '
	git archive HEAD >expect.tar &&
	nongit git archive --remote="$PWD" HEAD >actual.tar &&
	test_cmp_bin expect.tar actual.tar
'

test_expect_success 'clients cannot access unreachable commits' '
	test_commit unreachable &&
	sha1=$(git rev-parse HEAD) &&
	git reset --hard HEAD^ &&
	git archive $sha1 >remote.tar &&
	test_must_fail git archive --remote=. $sha1 >remote.tar
'

test_expect_success 'upload-archive can allow unreachable commits' '
	test_commit unreachable1 &&
	sha1=$(git rev-parse HEAD) &&
	git reset --hard HEAD^ &&
	git archive $sha1 >remote.tar &&
	test_config uploadarchive.allowUnreachable true &&
	git archive --remote=. $sha1 >remote.tar
'

test_expect_success 'setup tar filters' '
	git config tar.tar.foo.command "tr ab ba" &&
	git config tar.bar.command "tr ab ba" &&
	git config tar.bar.remote true &&
	git config tar.invalid baz
'

test_expect_success 'archive --list mentions user filter' '
	git archive --list >output &&
	grep "^tar\.foo\$" output &&
	grep "^bar\$" output
'

test_expect_success 'archive --list shows only enabled remote filters' '
	git archive --list --remote=. >output &&
	! grep "^tar\.foo\$" output &&
	grep "^bar\$" output
'

test_expect_success 'invoke tar filter by format' '
	git archive --format=tar.foo HEAD >config.tar.foo &&
	tr ab ba <config.tar.foo >config.tar &&
	test_cmp_bin b.tar config.tar &&
	git archive --format=bar HEAD >config.bar &&
	tr ab ba <config.bar >config.tar &&
	test_cmp_bin b.tar config.tar
'

test_expect_success 'invoke tar filter by extension' '
	git archive -o config-implicit.tar.foo HEAD &&
	test_cmp_bin config.tar.foo config-implicit.tar.foo &&
	git archive -o config-implicit.bar HEAD &&
	test_cmp_bin config.tar.foo config-implicit.bar
'

test_expect_success 'default output format remains tar' '
	git archive -o config-implicit.baz HEAD &&
	test_cmp_bin b.tar config-implicit.baz
'

test_expect_success 'extension matching requires dot' '
	git archive -o config-implicittar.foo HEAD &&
	test_cmp_bin b.tar config-implicittar.foo
'

test_expect_success 'only enabled filters are available remotely' '
	test_must_fail git archive --remote=. --format=tar.foo HEAD \
		>remote.tar.foo &&
	git archive --remote=. --format=bar >remote.bar HEAD &&
	test_cmp_bin remote.bar config.bar
'

test_expect_success GZIP 'git archive --format=tgz' '
	git archive --format=tgz HEAD >j.tgz
'

test_expect_success GZIP 'git archive --format=tar.gz' '
	git archive --format=tar.gz HEAD >j1.tar.gz &&
	test_cmp_bin j.tgz j1.tar.gz
'

test_expect_success GZIP 'infer tgz from .tgz filename' '
	git archive --output=j2.tgz HEAD &&
	test_cmp_bin j.tgz j2.tgz
'

test_expect_success GZIP 'infer tgz from .tar.gz filename' '
	git archive --output=j3.tar.gz HEAD &&
	test_cmp_bin j.tgz j3.tar.gz
'

test_expect_success GZIP 'extract tgz file' '
	gzip -d -c <j.tgz >j.tar &&
	test_cmp_bin b.tar j.tar
'

test_expect_success GZIP 'remote tar.gz is allowed by default' '
	git archive --remote=. --format=tar.gz HEAD >remote.tar.gz &&
	test_cmp_bin j.tgz remote.tar.gz
'

test_expect_success GZIP 'remote tar.gz can be disabled' '
	git config tar.tar.gz.remote false &&
	test_must_fail git archive --remote=. --format=tar.gz HEAD \
		>remote.tar.gz
'

test_expect_success 'archive and :(glob)' '
	git archive -v HEAD -- ":(glob)**/sh" >/dev/null 2>actual &&
	cat >expect <<EOF &&
a/
a/bin/
a/bin/sh
EOF
	test_cmp expect actual
'

test_expect_success 'catch non-matching pathspec' '
	test_must_fail git archive -v HEAD -- "*.abc" >/dev/null
'

# Pull the size and date of each entry in a tarfile using the system tar.
#
# We'll pull out only the year from the date; that avoids any question of
# timezones impacting the result (as long as we keep our test times away from a
# year boundary; our reference times are all in August).
#
# The output of tar_info is expected to be "<size> <year>", both in decimal. It
# ignores the return value of tar. We have to do this, because some of our test
# input is only partial (the real data is 64GB in some cases).
tar_info () {
	"$TAR" tvf "$1" |
	awk '{
		split($4, date, "-")
		print $3 " " date[1]
	}'
}

# See if our system tar can handle a tar file with huge sizes and dates far in
# the future, and that we can actually parse its output.
#
# The reference file was generated by GNU tar, and the magic time and size are
# both octal 01000000000001, which overflows normal ustar fields.
test_lazy_prereq TAR_HUGE '
	echo "68719476737 4147" >expect &&
	tar_info "$TEST_DIRECTORY"/t5000/huge-and-future.tar >actual &&
	test_cmp expect actual
'

test_expect_success LONG_IS_64BIT 'set up repository with huge blob' '
	obj=$(test_oid obj) &&
	path=$(test_oid_to_path $obj) &&
	mkdir -p .git/objects/$(dirname $path) &&
	cp "$TEST_DIRECTORY"/t5000/huge-object .git/objects/$path &&
	rm -f .git/index &&
	git update-index --add --cacheinfo 100644,$obj,huge &&
	git commit -m huge
'

# We expect git to die with SIGPIPE here (otherwise we
# would generate the whole 64GB).
test_expect_success LONG_IS_64BIT 'generate tar with huge size' '
	{
		git archive HEAD
		echo $? >exit-code
	} | test_copy_bytes 4096 >huge.tar &&
	echo 141 >expect &&
	test_cmp expect exit-code
'

test_expect_success TAR_HUGE,LONG_IS_64BIT 'system tar can read our huge size' '
	echo 68719476737 >expect &&
	tar_info huge.tar | cut -d" " -f1 >actual &&
	test_cmp expect actual
'

test_expect_success TIME_IS_64BIT 'set up repository with far-future commit' '
	rm -f .git/index &&
	echo content >file &&
	git add file &&
	GIT_COMMITTER_DATE="@68719476737 +0000" \
		git commit -m "tempori parendum"
'

test_expect_success TIME_IS_64BIT 'generate tar with future mtime' '
	git archive HEAD >future.tar
'

test_expect_success TAR_HUGE,TIME_IS_64BIT,TIME_T_IS_64BIT 'system tar can read our future mtime' '
	echo 4147 >expect &&
	tar_info future.tar | cut -d" " -f2 >actual &&
	test_cmp expect actual
'

test_done
Commit	Line	Data
d3d49c3d RS	1	#!/bin/sh
	2	#
	3	# Copyright (C) 2005 Rene Scharfe
	4	#
	5
925ceccf	6	test_description='git archive and git get-tar-commit-id test
d3d49c3d	7
5b860406 RS	8	This test covers the topics of file contents, commit date handling and
5b860406 RS	9	commit id embedding:
d3d49c3d RS	10
	11	The contents of the repository is compared to the extracted tar
	12	archive. The repository contains simple text files, symlinks and a
3dff5379	13	binary file (/bin/sh). Only paths shorter than 99 characters are
5b860406	14	used.
d3d49c3d	15
925ceccf	16	git archive applies the commit date to every file in the archive it
d3d49c3d RS	17	creates. The test sets the commit date to a specific value and checks
	18	if the tar archive contains that value.
	19
925ceccf	20	When giving git archive a commit id (in contrast to a tree id) it
d3d49c3d	21	embeds this commit id into the tar archive as a comment. The test
5be60078	22	checks the ability of git get-tar-commit-id to figure it out from the
d3d49c3d RS	23	tar file.
	24
	25	'
	26
	27	. ./test-lib.sh
	28
38c9c9b7	29	SUBSTFORMAT=%H%n
8460b2fc	30
9bf1ac41 RS	31	test_lazy_prereq TAR_NEEDS_PAX_FALLBACK '
	32	(
	33	mkdir pax &&
	34	cd pax &&
	35	"$TAR" xf "$TEST_DIRECTORY"/t5000/pax.tar &&
	36	test -f PaxHeaders.1791/file
	37	)
	38	'
	39
96174145 JK	40	test_lazy_prereq GZIP 'gzip --version'
96174145 JK	41
9bf1ac41 RS	42	get_pax_header() {
	43	file=$1
	44	header=$2=
	45
	46	while read len rest
	47	do
	48	if test "$len" = $(echo "$len $rest" \| wc -c)
	49	then
	50	case "$rest" in
	51	$header*)
	52	echo "${rest#$header}"
	53	;;
	54	esac
	55	fi
	56	done <"$file"
	57	}
	58
deb9c8ed RS	59	check_tar() {
	60	tarfile=$1.tar
	61	listfile=$1.lst
	62	dir=$1
	63	dir_with_prefix=$dir/$2
	64
	65	test_expect_success ' extract tar archive' '
	66	(mkdir $dir && cd $dir && "$TAR" xf -) <$tarfile
	67	'
	68
9bf1ac41 RS	69	test_expect_success TAR_NEEDS_PAX_FALLBACK ' interpret pax headers' '
	70	(
	71	cd $dir &&
	72	for header in *.paxheader
	73	do
	74	data=${header%.paxheader}.data &&
d0b30a3d	75	if test -h $data \|\| test -e $data
9bf1ac41 RS	76	then
	77	path=$(get_pax_header $header path) &&
	78	if test -n "$path"
	79	then
	80	mv "$data" "$path"
	81	fi
	82	fi
	83	done
	84	)
	85	'
	86
deb9c8ed RS	87	test_expect_success ' validate filenames' '
	88	(cd ${dir_with_prefix}a && find .) \| sort >$listfile &&
	89	test_cmp a.lst $listfile
	90	'
	91
	92	test_expect_success ' validate file contents' '
	93	diff -r a ${dir_with_prefix}a
	94	'
	95	}
	96
2947a793 RS	97	check_added() {
	98	dir=$1
	99	path_in_fs=$2
	100	path_in_archive=$3
	101
	102	test_expect_success " validate extra file $path_in_archive" '
	103	diff -r $path_in_fs $dir/$path_in_archive
	104	'
	105	}
	106
0b78a1b2	107	test_expect_success 'setup' '
	108	test_oid_cache <<-EOF
	109	obj sha1:19f9c8273ec45a8938e6999cb59b3ff66739902a
	110	obj sha256:3c666f798798601571f5cec0adb57ce4aba8546875e7693177e0535f34d2c49b
	111	EOF
	112	'
	113
d3d49c3d RS	114	test_expect_success \
d3d49c3d RS	115	'populate workdir' \
1355241b	116	'mkdir a &&
d3d49c3d	117	echo simple textfile >a/a &&
9bf1ac41 RS	118	ten=0123456789 && hundred=$ten$ten$ten$ten$ten$ten$ten$ten$ten$ten &&
9bf1ac41 RS	119	echo long filename >a/four$hundred &&
d3d49c3d	120	mkdir a/bin &&
c680668d	121	test-tool genrandom "frotz" 500000 >a/bin/sh &&
760da960 RS	122	printf "A\$Format:%s\$O" "$SUBSTFORMAT" >a/substfile1 &&
760da960 RS	123	printf "A not substituted O" >a/substfile2 &&
704a3143 JS	124	if test_have_prereq SYMLINKS; then
	125	ln -s a a/l1
	126	else
	127	printf %s a > a/l1
	128	fi &&
4c691724 RS	129	(p=long_path_to_a_file && cd a &&
	130	for depth in 1 2 3 4 5; do mkdir $p && cd $p; done &&
	131	echo text >file_with_long_path) &&
d3d49c3d RS	132	(cd a && find .) \| sort >a.lst'
d3d49c3d RS	133
008d896d RS	134	test_expect_success \
	135	'add ignored file' \
	136	'echo ignore me >a/ignored &&
ad94657f	137	echo ignored export-ignore >.git/info/attributes'
008d896d	138
21711ca4 RS	139	test_expect_success 'add files to repository' '
	140	git add a &&
	141	GIT_COMMITTER_DATE="2005-05-27 22:00" git commit -m initial
	142	'
d3d49c3d	143
c420df7b RS	144	test_expect_success 'setup export-subst' '
	145	echo "substfile?" export-subst >>.git/info/attributes &&
	146	git log --max-count=1 "--pretty=format:A${SUBSTFORMAT}O" HEAD \
	147	>a/substfile1
	148	'
	149
ddff8563 CB	150	test_expect_success \
	151	'create bare clone' \
	152	'git clone --bare . bare.git &&
ad94657f	153	cp .git/info/attributes bare.git/info/attributes'
ddff8563	154
008d896d RS	155	test_expect_success \
	156	'remove ignored file' \
	157	'rm a/ignored'
	158
8ff21b1a	159	test_expect_success \
5be60078 JH	160	'git archive' \
5be60078 JH	161	'git archive HEAD >b.tar'
8ff21b1a	162
deb9c8ed RS	163	check_tar b
deb9c8ed RS	164
03d9bc56 RS	165	test_expect_success 'git archive --prefix=prefix/' '
	166	git archive --prefix=prefix/ HEAD >with_prefix.tar
	167	'
	168
	169	check_tar with_prefix prefix/
	170
	171	test_expect_success 'git-archive --prefix=olde-' '
	172	git archive --prefix=olde- HEAD >with_olde-prefix.tar
	173	'
	174
	175	check_tar with_olde-prefix olde-
	176
2947a793 RS	177	test_expect_success 'git archive --add-file' '
	178	echo untracked >untracked &&
	179	git archive --add-file=untracked HEAD >with_untracked.tar
	180	'
	181
	182	check_tar with_untracked
	183	check_added with_untracked untracked untracked
	184
	185	test_expect_success 'git archive --add-file twice' '
	186	echo untracked >untracked &&
	187	git archive --prefix=one/ --add-file=untracked \
	188	--prefix=two/ --add-file=untracked \
	189	--prefix= HEAD >with_untracked2.tar
	190	'
	191
	192	check_tar with_untracked2
	193	check_added with_untracked2 untracked one/untracked
	194	check_added with_untracked2 untracked two/untracked
	195
5544049d NTND	196	test_expect_success 'git archive on large files' '
	197	test_config core.bigfilethreshold 1 &&
	198	git archive HEAD >b3.tar &&
b93e6e36	199	test_cmp_bin b.tar b3.tar
5544049d NTND	200	'
5544049d NTND	201
ddff8563 CB	202	test_expect_success \
	203	'git archive in a bare repo' \
	204	'(cd bare.git && git archive HEAD) >b3.tar'
	205
	206	test_expect_success \
	207	'git archive vs. the same in a bare repo' \
b93e6e36	208	'test_cmp_bin b.tar b3.tar'
ddff8563	209
aec0c1bb CMDV	210	test_expect_success 'git archive with --output' \
aec0c1bb CMDV	211	'git archive --output=b4.tar HEAD &&
b93e6e36	212	test_cmp_bin b.tar b4.tar'
aec0c1bb	213
1bc01efe	214	test_expect_success 'git archive --remote' \
48139269	215	'git archive --remote=. HEAD >b5.tar &&
b93e6e36	216	test_cmp_bin b.tar b5.tar'
48139269	217
eb0224c6 JH	218	test_expect_success 'git archive --remote with configured remote' '
	219	git config remote.foo.url . &&
	220	(
	221	cd a &&
	222	git archive --remote=foo --output=../b5-nick.tar HEAD
	223	) &&
	224	test_cmp_bin b.tar b5-nick.tar
	225	'
	226
d3d49c3d RS	227	test_expect_success \
d3d49c3d RS	228	'validate file modification time' \
30684dfa	229	'mkdir extract &&
bfce5087	230	"$TAR" xf b.tar -C extract a/a &&
deb9845a	231	test-tool chmtime --get extract/a/a >b.mtime &&
30684dfa	232	echo "1117231200" >expected.mtime &&
188c3827	233	test_cmp expected.mtime b.mtime'
d3d49c3d RS	234
d3d49c3d RS	235	test_expect_success \
5be60078 JH	236	'git get-tar-commit-id' \
5be60078 JH	237	'git get-tar-commit-id <b.tar >b.commitid &&
188c3827	238	test_cmp .git/$(git symbolic-ref HEAD) b.commitid'
d3d49c3d	239
fe12d8e8 RS	240	test_expect_success 'git archive with --output, override inferred format' '
fe12d8e8 RS	241	git archive --format=tar --output=d4.zip HEAD &&
b93e6e36	242	test_cmp_bin b.tar d4.zip
fe12d8e8 RS	243	'
fe12d8e8 RS	244
00436bf1 JS	245	test_expect_success GZIP 'git archive with --output and --remote creates .tgz' '
	246	git archive --output=d5.tgz --remote=. HEAD &&
	247	gzip -d -c <d5.tgz >d5.tar &&
	248	test_cmp_bin b.tar d5.tar
	249	'
	250
eb0224c6 JH	251	test_expect_success 'git archive --list outside of a git repo' '
	252	nongit git archive --list
	253	'
	254
	255	test_expect_success 'git archive --remote outside of a git repo' '
	256	git archive HEAD >expect.tar &&
	257	nongit git archive --remote="$PWD" HEAD >actual.tar &&
	258	test_cmp_bin expect.tar actual.tar
	259	'
265d5280	260
ee27ca4a JK	261	test_expect_success 'clients cannot access unreachable commits' '
ee27ca4a JK	262	test_commit unreachable &&
f5efd519	263	sha1=$(git rev-parse HEAD) &&
ee27ca4a JK	264	git reset --hard HEAD^ &&
	265	git archive $sha1 >remote.tar &&
	266	test_must_fail git archive --remote=. $sha1 >remote.tar
	267	'
	268
7671b632 SG	269	test_expect_success 'upload-archive can allow unreachable commits' '
7671b632 SG	270	test_commit unreachable1 &&
f5efd519	271	sha1=$(git rev-parse HEAD) &&
7671b632 SG	272	git reset --hard HEAD^ &&
	273	git archive $sha1 >remote.tar &&
	274	test_config uploadarchive.allowUnreachable true &&
	275	git archive --remote=. $sha1 >remote.tar
	276	'
	277
767cf457 JK	278	test_expect_success 'setup tar filters' '
767cf457 JK	279	git config tar.tar.foo.command "tr ab ba" &&
7b97730b	280	git config tar.bar.command "tr ab ba" &&
785a0429 JK	281	git config tar.bar.remote true &&
785a0429 JK	282	git config tar.invalid baz
767cf457 JK	283	'
	284
	285	test_expect_success 'archive --list mentions user filter' '
	286	git archive --list >output &&
	287	grep "^tar\.foo\$" output &&
	288	grep "^bar\$" output
	289	'
	290
1bc01efe	291	test_expect_success 'archive --list shows only enabled remote filters' '
767cf457	292	git archive --list --remote=. >output &&
7b97730b	293	! grep "^tar\.foo\$" output &&
767cf457 JK	294	grep "^bar\$" output
	295	'
	296
	297	test_expect_success 'invoke tar filter by format' '
	298	git archive --format=tar.foo HEAD >config.tar.foo &&
	299	tr ab ba <config.tar.foo >config.tar &&
b93e6e36	300	test_cmp_bin b.tar config.tar &&
767cf457 JK	301	git archive --format=bar HEAD >config.bar &&
767cf457 JK	302	tr ab ba <config.bar >config.tar &&
b93e6e36	303	test_cmp_bin b.tar config.tar
767cf457 JK	304	'
	305
	306	test_expect_success 'invoke tar filter by extension' '
	307	git archive -o config-implicit.tar.foo HEAD &&
b93e6e36	308	test_cmp_bin config.tar.foo config-implicit.tar.foo &&
767cf457	309	git archive -o config-implicit.bar HEAD &&
b93e6e36	310	test_cmp_bin config.tar.foo config-implicit.bar
767cf457 JK	311	'
	312
	313	test_expect_success 'default output format remains tar' '
	314	git archive -o config-implicit.baz HEAD &&
b93e6e36	315	test_cmp_bin b.tar config-implicit.baz
767cf457 JK	316	'
	317
	318	test_expect_success 'extension matching requires dot' '
	319	git archive -o config-implicittar.foo HEAD &&
b93e6e36	320	test_cmp_bin b.tar config-implicittar.foo
767cf457 JK	321	'
767cf457 JK	322
1bc01efe	323	test_expect_success 'only enabled filters are available remotely' '
7b97730b JK	324	test_must_fail git archive --remote=. --format=tar.foo HEAD \
	325	>remote.tar.foo &&
	326	git archive --remote=. --format=bar >remote.bar HEAD &&
b93e6e36	327	test_cmp_bin remote.bar config.bar
7b97730b JK	328	'
7b97730b JK	329
0e804e09 JK	330	test_expect_success GZIP 'git archive --format=tgz' '
	331	git archive --format=tgz HEAD >j.tgz
	332	'
	333
	334	test_expect_success GZIP 'git archive --format=tar.gz' '
	335	git archive --format=tar.gz HEAD >j1.tar.gz &&
b93e6e36	336	test_cmp_bin j.tgz j1.tar.gz
0e804e09 JK	337	'
	338
	339	test_expect_success GZIP 'infer tgz from .tgz filename' '
	340	git archive --output=j2.tgz HEAD &&
b93e6e36	341	test_cmp_bin j.tgz j2.tgz
0e804e09 JK	342	'
	343
	344	test_expect_success GZIP 'infer tgz from .tar.gz filename' '
	345	git archive --output=j3.tar.gz HEAD &&
b93e6e36	346	test_cmp_bin j.tgz j3.tar.gz
0e804e09 JK	347	'
0e804e09 JK	348
96174145 JK	349	test_expect_success GZIP 'extract tgz file' '
96174145 JK	350	gzip -d -c <j.tgz >j.tar &&
b93e6e36	351	test_cmp_bin b.tar j.tar
0e804e09 JK	352	'
0e804e09 JK	353
1bc01efe	354	test_expect_success GZIP 'remote tar.gz is allowed by default' '
7b97730b	355	git archive --remote=. --format=tar.gz HEAD >remote.tar.gz &&
b93e6e36	356	test_cmp_bin j.tgz remote.tar.gz
7b97730b JK	357	'
7b97730b JK	358
1bc01efe	359	test_expect_success GZIP 'remote tar.gz can be disabled' '
7b97730b JK	360	git config tar.tar.gz.remote false &&
	361	test_must_fail git archive --remote=. --format=tar.gz HEAD \
	362	>remote.tar.gz
	363	'
	364
ed22b417 NTND	365	test_expect_success 'archive and :(glob)' '
	366	git archive -v HEAD -- ":(glob)**/sh" >/dev/null 2>actual &&
	367	cat >expect <<EOF &&
	368	a/
	369	a/bin/
	370	a/bin/sh
	371	EOF
	372	test_cmp expect actual
	373	'
	374
	375	test_expect_success 'catch non-matching pathspec' '
	376	test_must_fail git archive -v HEAD -- "*.abc" >/dev/null
	377	'
	378
e51217e1 JK	379	# Pull the size and date of each entry in a tarfile using the system tar.
	380	#
	381	# We'll pull out only the year from the date; that avoids any question of
	382	# timezones impacting the result (as long as we keep our test times away from a
	383	# year boundary; our reference times are all in August).
	384	#
	385	# The output of tar_info is expected to be "<size> <year>", both in decimal. It
	386	# ignores the return value of tar. We have to do this, because some of our test
	387	# input is only partial (the real data is 64GB in some cases).
	388	tar_info () {
	389	"$TAR" tvf "$1" \|
	390	awk '{
	391	split($4, date, "-")
	392	print $3 " " date[1]
	393	}'
	394	}
	395
	396	# See if our system tar can handle a tar file with huge sizes and dates far in
	397	# the future, and that we can actually parse its output.
	398	#
	399	# The reference file was generated by GNU tar, and the magic time and size are
	400	# both octal 01000000000001, which overflows normal ustar fields.
	401	test_lazy_prereq TAR_HUGE '
	402	echo "68719476737 4147" >expect &&
	403	tar_info "$TEST_DIRECTORY"/t5000/huge-and-future.tar >actual &&
	404	test_cmp expect actual
	405	'
	406
29493589	407	test_expect_success LONG_IS_64BIT 'set up repository with huge blob' '
0b78a1b2	408	obj=$(test_oid obj) &&
	409	path=$(test_oid_to_path $obj) &&
	410	mkdir -p .git/objects/$(dirname $path) &&
	411	cp "$TEST_DIRECTORY"/t5000/huge-object .git/objects/$path &&
e51217e1 JK	412	rm -f .git/index &&
	413	git update-index --add --cacheinfo 100644,$obj,huge &&
	414	git commit -m huge
	415	'
	416
	417	# We expect git to die with SIGPIPE here (otherwise we
	418	# would generate the whole 64GB).
29493589	419	test_expect_success LONG_IS_64BIT 'generate tar with huge size' '
e51217e1 JK	420	{
	421	git archive HEAD
	422	echo $? >exit-code
	423	} \| test_copy_bytes 4096 >huge.tar &&
	424	echo 141 >expect &&
	425	test_cmp expect exit-code
	426	'
	427
29493589	428	test_expect_success TAR_HUGE,LONG_IS_64BIT 'system tar can read our huge size' '
e51217e1 JK	429	echo 68719476737 >expect &&
	430	tar_info huge.tar \| cut -d" " -f1 >actual &&
	431	test_cmp expect actual
	432	'
	433
a07fb050	434	test_expect_success TIME_IS_64BIT 'set up repository with far-future commit' '
e51217e1 JK	435	rm -f .git/index &&
	436	echo content >file &&
	437	git add file &&
	438	GIT_COMMITTER_DATE="@68719476737 +0000" \
	439	git commit -m "tempori parendum"
	440	'
	441
a07fb050	442	test_expect_success TIME_IS_64BIT 'generate tar with future mtime' '
e51217e1 JK	443	git archive HEAD >future.tar
	444	'
	445
efac8ac8	446	test_expect_success TAR_HUGE,TIME_IS_64BIT,TIME_T_IS_64BIT 'system tar can read our future mtime' '
e51217e1 JK	447	echo 4147 >expect &&
	448	tar_info future.tar \| cut -d" " -f2 >actual &&
	449	test_cmp expect actual
	450	'
	451
d3d49c3d	452	test_done