t/t5000-tar-tree.sh

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