t/t5329-pack-objects-cruft.sh

   1 #!/bin/sh
   2
   3 test_description='cruft pack related pack-objects tests'
   4 . ./test-lib.sh
   5
   6 objdir=.git/objects
   7 packdir=$objdir/pack
   8
   9 basic_cruft_pack_tests () {
  10         expire="$1"
  11
  12         test_expect_success "unreachable loose objects are packed (expire $expire)" '
  13                 git init repo &&
  14                 test_when_finished "rm -fr repo" &&
  15                 (
  16                         cd repo &&
  17
  18                         test_commit base &&
  19                         git repack -Ad &&
  20                         test_commit loose &&
  21
  22                         test-tool chmtime +2000 "$objdir/$(test_oid_to_path \
  23                                 $(git rev-parse loose:loose.t))" &&
  24                         test-tool chmtime +1000 "$objdir/$(test_oid_to_path \
  25                                 $(git rev-parse loose^{tree}))" &&
  26
  27                         (
  28                                 git rev-list --objects --no-object-names base..loose |
  29                                 while read oid
  30                                 do
  31                                         path="$objdir/$(test_oid_to_path "$oid")" &&
  32                                         printf "%s %d\n" "$oid" "$(test-tool chmtime --get "$path")" ||
  33                                         echo "object list generation failed for $oid"
  34                                 done |
  35                                 sort -k1
  36                         ) >expect &&
  37
  38                         keep="$(basename "$(ls $packdir/pack-*.pack)")" &&
  39                         cruft="$(echo $keep | git pack-objects --cruft \
  40                                 --cruft-expiration="$expire" $packdir/pack)" &&
  41                         test-tool pack-mtimes "pack-$cruft.mtimes" >actual &&
  42
  43                         test_cmp expect actual
  44                 )
  45         '
  46
  47         test_expect_success "unreachable packed objects are packed (expire $expire)" '
  48                 git init repo &&
  49                 test_when_finished "rm -fr repo" &&
  50                 (
  51                         cd repo &&
  52
  53                         test_commit packed &&
  54                         git repack -Ad &&
  55                         test_commit other &&
  56
  57                         git rev-list --objects --no-object-names packed.. >objects &&
  58                         keep="$(basename "$(ls $packdir/pack-*.pack)")" &&
  59                         other="$(git pack-objects --delta-base-offset \
  60                                 $packdir/pack <objects)" &&
  61                         git prune-packed &&
  62
  63                         test-tool chmtime --get -100 "$packdir/pack-$other.pack" >expect &&
  64
  65                         cruft="$(git pack-objects --cruft --cruft-expiration="$expire" $packdir/pack <<-EOF
  66                         $keep
  67                         -pack-$other.pack
  68                         EOF
  69                         )" &&
  70                         test-tool pack-mtimes "pack-$cruft.mtimes" >actual.raw &&
  71
  72                         cut -d" " -f2 <actual.raw | sort -u >actual &&
  73
  74                         test_cmp expect actual
  75                 )
  76         '
  77
  78         test_expect_success "unreachable cruft objects are repacked (expire $expire)" '
  79                 git init repo &&
  80                 test_when_finished "rm -fr repo" &&
  81                 (
  82                         cd repo &&
  83
  84                         test_commit packed &&
  85                         git repack -Ad &&
  86                         test_commit other &&
  87
  88                         git rev-list --objects --no-object-names packed.. >objects &&
  89                         keep="$(basename "$(ls $packdir/pack-*.pack)")" &&
  90
  91                         cruft_a="$(echo $keep | git pack-objects --cruft --cruft-expiration="$expire" $packdir/pack)" &&
  92                         git prune-packed &&
  93                         cruft_b="$(git pack-objects --cruft --cruft-expiration="$expire" $packdir/pack <<-EOF
  94                         $keep
  95                         -pack-$cruft_a.pack
  96                         EOF
  97                         )" &&
  98
  99                         test-tool pack-mtimes "pack-$cruft_a.mtimes" >expect.raw &&
 100                         test-tool pack-mtimes "pack-$cruft_b.mtimes" >actual.raw &&
 101
 102                         sort <expect.raw >expect &&
 103                         sort <actual.raw >actual &&
 104
 105                         test_cmp expect actual
 106                 )
 107         '
 108
 109         test_expect_success "multiple cruft packs (expire $expire)" '
 110                 git init repo &&
 111                 test_when_finished "rm -fr repo" &&
 112                 (
 113                         cd repo &&
 114
 115                         test_commit reachable &&
 116                         git repack -Ad &&
 117                         keep="$(basename "$(ls $packdir/pack-*.pack)")" &&
 118
 119                         test_commit cruft &&
 120                         loose="$objdir/$(test_oid_to_path $(git rev-parse cruft))" &&
 121
 122                         # generate three copies of the cruft object in different
 123                         # cruft packs, each with a unique mtime:
 124                         #   - one expired (1000 seconds ago)
 125                         #   - two non-expired (one 1000 seconds in the future,
 126                         #     one 1500 seconds in the future)
 127                         test-tool chmtime =-1000 "$loose" &&
 128                         git pack-objects --cruft $packdir/pack-A <<-EOF &&
 129                         $keep
 130                         EOF
 131                         test-tool chmtime =+1000 "$loose" &&
 132                         git pack-objects --cruft $packdir/pack-B <<-EOF &&
 133                         $keep
 134                         -$(basename $(ls $packdir/pack-A-*.pack))
 135                         EOF
 136                         test-tool chmtime =+1500 "$loose" &&
 137                         git pack-objects --cruft $packdir/pack-C <<-EOF &&
 138                         $keep
 139                         -$(basename $(ls $packdir/pack-A-*.pack))
 140                         -$(basename $(ls $packdir/pack-B-*.pack))
 141                         EOF
 142
 143                         # ensure the resulting cruft pack takes the most recent
 144                         # mtime among all copies
 145                         cruft="$(git pack-objects --cruft \
 146                                 --cruft-expiration="$expire" \
 147                                 $packdir/pack <<-EOF
 148                         $keep
 149                         -$(basename $(ls $packdir/pack-A-*.pack))
 150                         -$(basename $(ls $packdir/pack-B-*.pack))
 151                         -$(basename $(ls $packdir/pack-C-*.pack))
 152                         EOF
 153                         )" &&
 154
 155                         test-tool pack-mtimes "$(basename $(ls $packdir/pack-C-*.mtimes))" >expect.raw &&
 156                         test-tool pack-mtimes "pack-$cruft.mtimes" >actual.raw &&
 157
 158                         sort expect.raw >expect &&
 159                         sort actual.raw >actual &&
 160                         test_cmp expect actual
 161                 )
 162         '
 163
 164         test_expect_success "cruft packs tolerate missing trees (expire $expire)" '
 165                 git init repo &&
 166                 test_when_finished "rm -fr repo" &&
 167                 (
 168                         cd repo &&
 169
 170                         test_commit reachable &&
 171                         test_commit cruft &&
 172
 173                         tree="$(git rev-parse cruft^{tree})" &&
 174
 175                         git reset --hard reachable &&
 176                         git tag -d cruft &&
 177                         git reflog expire --all --expire=all &&
 178
 179                         # remove the unreachable tree, but leave the commit
 180                         # which has it as its root tree intact
 181                         rm -fr "$objdir/$(test_oid_to_path "$tree")" &&
 182
 183                         git repack -Ad &&
 184                         basename $(ls $packdir/pack-*.pack) >in &&
 185                         git pack-objects --cruft --cruft-expiration="$expire" \
 186                                 $packdir/pack <in
 187                 )
 188         '
 189
 190         test_expect_success "cruft packs tolerate missing blobs (expire $expire)" '
 191                 git init repo &&
 192                 test_when_finished "rm -fr repo" &&
 193                 (
 194                         cd repo &&
 195
 196                         test_commit reachable &&
 197                         test_commit cruft &&
 198
 199                         blob="$(git rev-parse cruft:cruft.t)" &&
 200
 201                         git reset --hard reachable &&
 202                         git tag -d cruft &&
 203                         git reflog expire --all --expire=all &&
 204
 205                         # remove the unreachable blob, but leave the commit (and
 206                         # the root tree of that commit) intact
 207                         rm -fr "$objdir/$(test_oid_to_path "$blob")" &&
 208
 209                         git repack -Ad &&
 210                         basename $(ls $packdir/pack-*.pack) >in &&
 211                         git pack-objects --cruft --cruft-expiration="$expire" \
 212                                 $packdir/pack <in
 213                 )
 214         '
 215 }
 216
 217 basic_cruft_pack_tests never
 218 basic_cruft_pack_tests 2.weeks.ago
 219
 220 test_expect_success 'cruft tags rescue tagged objects' '
 221         git init repo &&
 222         test_when_finished "rm -fr repo" &&
 223         (
 224                 cd repo &&
 225
 226                 test_commit packed &&
 227                 git repack -Ad &&
 228
 229                 test_commit tagged &&
 230                 git tag -a annotated -m tag &&
 231
 232                 git rev-list --objects --no-object-names packed.. >objects &&
 233                 while read oid
 234                 do
 235                         test-tool chmtime -1000 \
 236                                 "$objdir/$(test_oid_to_path $oid)" || exit 1
 237                 done <objects &&
 238
 239                 test-tool chmtime -500 \
 240                         "$objdir/$(test_oid_to_path $(git rev-parse annotated))" &&
 241
 242                 keep="$(basename "$(ls $packdir/pack-*.pack)")" &&
 243                 cruft="$(echo $keep | git pack-objects --cruft \
 244                         --cruft-expiration=750.seconds.ago \
 245                         $packdir/pack)" &&
 246                 test-tool pack-mtimes "pack-$cruft.mtimes" >actual.raw &&
 247                 cut -f1 -d" " <actual.raw | sort >actual &&
 248
 249                 (
 250                         cat objects &&
 251                         git rev-parse annotated
 252                 ) >expect.raw &&
 253                 sort <expect.raw >expect &&
 254
 255                 test_cmp expect actual &&
 256                 cat actual
 257         )
 258 '
 259
 260 test_expect_success 'cruft commits rescue parents, trees' '
 261         git init repo &&
 262         test_when_finished "rm -fr repo" &&
 263         (
 264                 cd repo &&
 265
 266                 test_commit packed &&
 267                 git repack -Ad &&
 268
 269                 test_commit old &&
 270                 test_commit new &&
 271
 272                 git rev-list --objects --no-object-names packed..new >objects &&
 273                 while read object
 274                 do
 275                         test-tool chmtime -1000 \
 276                                 "$objdir/$(test_oid_to_path $object)" || exit 1
 277                 done <objects &&
 278                 test-tool chmtime +500 "$objdir/$(test_oid_to_path \
 279                         $(git rev-parse HEAD))" &&
 280
 281                 keep="$(basename "$(ls $packdir/pack-*.pack)")" &&
 282                 cruft="$(echo $keep | git pack-objects --cruft \
 283                         --cruft-expiration=750.seconds.ago \
 284                         $packdir/pack)" &&
 285                 test-tool pack-mtimes "pack-$cruft.mtimes" >actual.raw &&
 286
 287                 cut -d" " -f1 <actual.raw | sort >actual &&
 288                 sort <objects >expect &&
 289
 290                 test_cmp expect actual
 291         )
 292 '
 293
 294 test_expect_success 'cruft trees rescue sub-trees, blobs' '
 295         git init repo &&
 296         test_when_finished "rm -fr repo" &&
 297         (
 298                 cd repo &&
 299
 300                 test_commit packed &&
 301                 git repack -Ad &&
 302
 303                 mkdir -p dir/sub &&
 304                 echo foo >foo &&
 305                 echo bar >dir/bar &&
 306                 echo baz >dir/sub/baz &&
 307
 308                 test_tick &&
 309                 git add . &&
 310                 git commit -m "pruned" &&
 311
 312                 test-tool chmtime -1000 "$objdir/$(test_oid_to_path $(git rev-parse HEAD))" &&
 313                 test-tool chmtime -1000 "$objdir/$(test_oid_to_path $(git rev-parse HEAD^{tree}))" &&
 314                 test-tool chmtime -1000 "$objdir/$(test_oid_to_path $(git rev-parse HEAD:foo))" &&
 315                 test-tool chmtime  -500 "$objdir/$(test_oid_to_path $(git rev-parse HEAD:dir))" &&
 316                 test-tool chmtime -1000 "$objdir/$(test_oid_to_path $(git rev-parse HEAD:dir/bar))" &&
 317                 test-tool chmtime -1000 "$objdir/$(test_oid_to_path $(git rev-parse HEAD:dir/sub))" &&
 318                 test-tool chmtime -1000 "$objdir/$(test_oid_to_path $(git rev-parse HEAD:dir/sub/baz))" &&
 319
 320                 keep="$(basename "$(ls $packdir/pack-*.pack)")" &&
 321                 cruft="$(echo $keep | git pack-objects --cruft \
 322                         --cruft-expiration=750.seconds.ago \
 323                         $packdir/pack)" &&
 324                 test-tool pack-mtimes "pack-$cruft.mtimes" >actual.raw &&
 325                 cut -f1 -d" " <actual.raw | sort >actual &&
 326
 327                 git rev-parse HEAD:dir HEAD:dir/bar HEAD:dir/sub HEAD:dir/sub/baz >expect.raw &&
 328                 sort <expect.raw >expect &&
 329
 330                 test_cmp expect actual
 331         )
 332 '
 333
 334 test_expect_success 'expired objects are pruned' '
 335         git init repo &&
 336         test_when_finished "rm -fr repo" &&
 337         (
 338                 cd repo &&
 339
 340                 test_commit packed &&
 341                 git repack -Ad &&
 342
 343                 test_commit pruned &&
 344
 345                 git rev-list --objects --no-object-names packed..pruned >objects &&
 346                 while read object
 347                 do
 348                         test-tool chmtime -1000 \
 349                                 "$objdir/$(test_oid_to_path $object)" || exit 1
 350                 done <objects &&
 351
 352                 keep="$(basename "$(ls $packdir/pack-*.pack)")" &&
 353                 cruft="$(echo $keep | git pack-objects --cruft \
 354                         --cruft-expiration=750.seconds.ago \
 355                         $packdir/pack)" &&
 356
 357                 test-tool pack-mtimes "pack-$cruft.mtimes" >actual &&
 358                 test_must_be_empty actual
 359         )
 360 '
 361
 362 test_expect_success 'repack --cruft generates a cruft pack' '
 363         git init repo &&
 364         test_when_finished "rm -fr repo" &&
 365         (
 366                 cd repo &&
 367
 368                 test_commit reachable &&
 369                 git branch -M main &&
 370                 git checkout --orphan other &&
 371                 test_commit unreachable &&
 372
 373                 git checkout main &&
 374                 git branch -D other &&
 375                 git tag -d unreachable &&
 376                 # objects are not cruft if they are contained in the reflogs
 377                 git reflog expire --all --expire=all &&
 378
 379                 git rev-list --objects --all --no-object-names >reachable.raw &&
 380                 git cat-file --batch-all-objects --batch-check="%(objectname)" >objects &&
 381                 sort <reachable.raw >reachable &&
 382                 comm -13 reachable objects >unreachable &&
 383
 384                 git repack --cruft -d &&
 385
 386                 cruft=$(basename $(ls $packdir/pack-*.mtimes) .mtimes) &&
 387                 pack=$(basename $(ls $packdir/pack-*.pack | grep -v $cruft) .pack) &&
 388
 389                 git show-index <$packdir/$pack.idx >actual.raw &&
 390                 cut -f2 -d" " actual.raw | sort >actual &&
 391                 test_cmp reachable actual &&
 392
 393                 git show-index <$packdir/$cruft.idx >actual.raw &&
 394                 cut -f2 -d" " actual.raw | sort >actual &&
 395                 test_cmp unreachable actual
 396         )
 397 '
 398
 399 test_expect_success 'loose objects mtimes upsert others' '
 400         git init repo &&
 401         test_when_finished "rm -fr repo" &&
 402         (
 403                 cd repo &&
 404
 405                 test_commit reachable &&
 406                 git repack -Ad &&
 407                 git branch -M main &&
 408
 409                 git checkout --orphan other &&
 410                 test_commit cruft &&
 411                 # incremental repack, leaving existing objects loose (so
 412                 # they can be "freshened")
 413                 git repack &&
 414
 415                 tip="$(git rev-parse cruft)" &&
 416                 path="$objdir/$(test_oid_to_path "$tip")" &&
 417                 test-tool chmtime --get +1000 "$path" >expect &&
 418
 419                 git checkout main &&
 420                 git branch -D other &&
 421                 git tag -d cruft &&
 422                 git reflog expire --all --expire=all &&
 423
 424                 git repack --cruft -d &&
 425
 426                 mtimes="$(basename $(ls $packdir/pack-*.mtimes))" &&
 427                 test-tool pack-mtimes "$mtimes" >actual.raw &&
 428                 grep "$tip" actual.raw | cut -d" " -f2 >actual &&
 429                 test_cmp expect actual
 430         )
 431 '
 432
 433 test_expect_success 'expiring cruft objects with git gc' '
 434         git init repo &&
 435         test_when_finished "rm -fr repo" &&
 436         (
 437                 cd repo &&
 438
 439                 test_commit reachable &&
 440                 git branch -M main &&
 441                 git checkout --orphan other &&
 442                 test_commit unreachable &&
 443
 444                 git checkout main &&
 445                 git branch -D other &&
 446                 git tag -d unreachable &&
 447                 # objects are not cruft if they are contained in the reflogs
 448                 git reflog expire --all --expire=all &&
 449
 450                 git rev-list --objects --all --no-object-names >reachable.raw &&
 451                 git cat-file --batch-all-objects --batch-check="%(objectname)" >objects &&
 452                 sort <reachable.raw >reachable &&
 453                 comm -13 reachable objects >unreachable &&
 454
 455                 # Write a cruft pack containing all unreachable objects.
 456                 git gc --cruft --prune="01-01-1980" &&
 457
 458                 mtimes=$(ls .git/objects/pack/pack-*.mtimes) &&
 459                 test_path_is_file $mtimes &&
 460
 461                 # Prune all unreachable objects from the cruft pack.
 462                 git gc --cruft --prune=now &&
 463
 464                 git cat-file --batch-all-objects --batch-check="%(objectname)" >objects &&
 465
 466                 comm -23 unreachable objects >removed &&
 467                 test_cmp unreachable removed &&
 468                 test_path_is_missing $mtimes
 469         )
 470 '
 471
 472 test_expect_success 'cruft packs are not included in geometric repack' '
 473         git init repo &&
 474         test_when_finished "rm -fr repo" &&
 475         (
 476                 cd repo &&
 477
 478                 test_commit reachable &&
 479                 git repack -Ad &&
 480                 git branch -M main &&
 481
 482                 git checkout --orphan other &&
 483                 test_commit cruft &&
 484                 git repack -d &&
 485
 486                 git checkout main &&
 487                 git branch -D other &&
 488                 git tag -d cruft &&
 489                 git reflog expire --all --expire=all &&
 490
 491                 git repack --cruft &&
 492
 493                 find $packdir -type f | sort >before &&
 494                 git repack --geometric=2 -d &&
 495                 find $packdir -type f | sort >after &&
 496
 497                 test_cmp before after
 498         )
 499 '
 500
 501 test_expect_success 'repack --geometric collects once-cruft objects' '
 502         git init repo &&
 503         test_when_finished "rm -fr repo" &&
 504         (
 505                 cd repo &&
 506
 507                 test_commit reachable &&
 508                 git repack -Ad &&
 509                 git branch -M main &&
 510
 511                 git checkout --orphan other &&
 512                 git rm -rf . &&
 513                 test_commit --no-tag cruft &&
 514                 cruft="$(git rev-parse HEAD)" &&
 515
 516                 git checkout main &&
 517                 git branch -D other &&
 518                 git reflog expire --all --expire=all &&
 519
 520                 # Pack the objects created in the previous step into a cruft
 521                 # pack. Intentionally leave loose copies of those objects
 522                 # around so we can pick them up in a subsequent --geometric
 523                 # reapack.
 524                 git repack --cruft &&
 525
 526                 # Now make those objects reachable, and ensure that they are
 527                 # packed into the new pack created via a --geometric repack.
 528                 git update-ref refs/heads/other $cruft &&
 529
 530                 # Without this object, the set of unpacked objects is exactly
 531                 # the set of objects already in the cruft pack. Tweak that set
 532                 # to ensure we do not overwrite the cruft pack entirely.
 533                 test_commit reachable2 &&
 534
 535                 find $packdir -name "pack-*.idx" | sort >before &&
 536                 git repack --geometric=2 -d &&
 537                 find $packdir -name "pack-*.idx" | sort >after &&
 538
 539                 {
 540                         git rev-list --objects --no-object-names $cruft &&
 541                         git rev-list --objects --no-object-names reachable..reachable2
 542                 } >want.raw &&
 543                 sort want.raw >want &&
 544
 545                 pack=$(comm -13 before after) &&
 546                 git show-index <$pack >objects.raw &&
 547
 548                 cut -d" " -f2 objects.raw | sort >got &&
 549
 550                 test_cmp want got
 551         )
 552 '
 553
 554 test_expect_success 'cruft repack with no reachable objects' '
 555         git init repo &&
 556         test_when_finished "rm -fr repo" &&
 557         (
 558                 cd repo &&
 559
 560                 test_commit base &&
 561                 git repack -ad &&
 562
 563                 base="$(git rev-parse base)" &&
 564
 565                 git for-each-ref --format="delete %(refname)" >in &&
 566                 git update-ref --stdin <in &&
 567                 git reflog expire --all --expire=all &&
 568                 rm -fr .git/index &&
 569
 570                 git repack --cruft -d &&
 571
 572                 git cat-file -t $base
 573         )
 574 '
 575
 576 test_expect_success 'cruft repack ignores --max-pack-size' '
 577         git init max-pack-size &&
 578         (
 579                 cd max-pack-size &&
 580                 test_commit base &&
 581                 # two cruft objects which exceed the maximum pack size
 582                 test-tool genrandom foo 1048576 | git hash-object --stdin -w &&
 583                 test-tool genrandom bar 1048576 | git hash-object --stdin -w &&
 584                 git repack --cruft --max-pack-size=1M &&
 585                 find $packdir -name "*.mtimes" >cruft &&
 586                 test_line_count = 1 cruft &&
 587                 test-tool pack-mtimes "$(basename "$(cat cruft)")" >objects &&
 588                 test_line_count = 2 objects
 589         )
 590 '
 591
 592 test_expect_success 'cruft repack ignores pack.packSizeLimit' '
 593         (
 594                 cd max-pack-size &&
 595                 # repack everything back together to remove the existing cruft
 596                 # pack (but to keep its objects)
 597                 git repack -adk &&
 598                 git -c pack.packSizeLimit=1M repack --cruft &&
 599                 # ensure the same post condition is met when --max-pack-size
 600                 # would otherwise be inferred from the configuration
 601                 find $packdir -name "*.mtimes" >cruft &&
 602                 test_line_count = 1 cruft &&
 603                 test-tool pack-mtimes "$(basename "$(cat cruft)")" >objects &&
 604                 test_line_count = 2 objects
 605         )
 606 '
 607
 608 test_expect_success 'cruft repack respects repack.cruftWindow' '
 609         git init repo &&
 610         test_when_finished "rm -fr repo" &&
 611         (
 612                 cd repo &&
 613
 614                 test_commit base &&
 615
 616                 GIT_TRACE2_EVENT=$(pwd)/event.trace \
 617                 git -c pack.window=1 -c repack.cruftWindow=2 repack \
 618                        --cruft --window=3 &&
 619
 620                 grep "pack-objects.*--window=2.*--cruft" event.trace
 621         )
 622 '
 623
 624 test_expect_success 'cruft repack respects --window by default' '
 625         git init repo &&
 626         test_when_finished "rm -fr repo" &&
 627         (
 628                 cd repo &&
 629
 630                 test_commit base &&
 631
 632                 GIT_TRACE2_EVENT=$(pwd)/event.trace \
 633                 git -c pack.window=2 repack --cruft --window=3 &&
 634
 635                 grep "pack-objects.*--window=3.*--cruft" event.trace
 636         )
 637 '
 638
 639 test_expect_success 'cruft repack respects --quiet' '
 640         git init repo &&
 641         test_when_finished "rm -fr repo" &&
 642         (
 643                 cd repo &&
 644
 645                 test_commit base &&
 646                 GIT_PROGRESS_DELAY=0 git repack --cruft --quiet 2>err &&
 647                 test_must_be_empty err
 648         )
 649 '
 650
 651 test_expect_success 'cruft --local drops unreachable objects' '
 652         git init alternate &&
 653         git init repo &&
 654         test_when_finished "rm -fr alternate repo" &&
 655
 656         test_commit -C alternate base &&
 657         # Pack all objects in alterate so that the cruft repack in "repo" sees
 658         # the object it dropped due to `--local` as packed. Otherwise this
 659         # object would not appear packed anywhere (since it is not packed in
 660         # alternate and likewise not part of the cruft pack in the other repo
 661         # because of `--local`).
 662         git -C alternate repack -ad &&
 663
 664         (
 665                 cd repo &&
 666
 667                 object="$(git -C ../alternate rev-parse HEAD:base.t)" &&
 668                 git -C ../alternate cat-file -p $object >contents &&
 669
 670                 # Write some reachable objects and two unreachable ones: one
 671                 # that the alternate has and another that is unique.
 672                 test_commit other &&
 673                 git hash-object -w -t blob contents &&
 674                 cruft="$(echo cruft | git hash-object -w -t blob --stdin)" &&
 675
 676                 ( cd ../alternate/.git/objects && pwd ) \
 677                        >.git/objects/info/alternates &&
 678
 679                 test_path_is_file $objdir/$(test_oid_to_path $cruft) &&
 680                 test_path_is_file $objdir/$(test_oid_to_path $object) &&
 681
 682                 git repack -d --cruft --local &&
 683
 684                 test-tool pack-mtimes "$(basename $(ls $packdir/pack-*.mtimes))" \
 685                        >objects &&
 686                 ! grep $object objects &&
 687                 grep $cruft objects
 688         )
 689 '
 690
 691 test_expect_success 'MIDX bitmaps tolerate reachable cruft objects' '
 692         git init repo &&
 693         test_when_finished "rm -fr repo" &&
 694         (
 695                 cd repo &&
 696
 697                 test_commit reachable &&
 698                 test_commit cruft &&
 699                 unreachable="$(git rev-parse cruft)" &&
 700
 701                 git reset --hard $unreachable^ &&
 702                 git tag -d cruft &&
 703                 git reflog expire --all --expire=all &&
 704
 705                 git repack --cruft -d &&
 706
 707                 # resurrect the unreachable object via a new commit. the
 708                 # new commit will get selected for a bitmap, but be
 709                 # missing one of its parents from the selected packs.
 710                 git reset --hard $unreachable &&
 711                 test_commit resurrect &&
 712
 713                 git repack --write-midx --write-bitmap-index --geometric=2 -d
 714         )
 715 '
 716
 717 test_expect_success 'cruft objects are freshend via loose' '
 718         git init repo &&
 719         test_when_finished "rm -fr repo" &&
 720         (
 721                 cd repo &&
 722
 723                 echo "cruft" >contents &&
 724                 blob="$(git hash-object -w -t blob contents)" &&
 725                 loose="$objdir/$(test_oid_to_path $blob)" &&
 726
 727                 test_commit base &&
 728
 729                 git repack --cruft -d &&
 730
 731                 test_path_is_missing "$loose" &&
 732                 test-tool pack-mtimes "$(basename "$(ls $packdir/pack-*.mtimes)")" >cruft &&
 733                 grep "$blob" cruft &&
 734
 735                 # write the same object again
 736                 git hash-object -w -t blob contents &&
 737
 738                 test_path_is_file "$loose"
 739         )
 740 '
 741
 742 test_expect_success 'gc.recentObjectsHook' '
 743         git init repo &&
 744         test_when_finished "rm -fr repo" &&
 745         (
 746                 cd repo &&
 747
 748                 # Create a handful of objects.
 749                 #
 750                 #   - one reachable commit, "base", designated for the reachable
 751                 #     pack
 752                 #   - one unreachable commit, "cruft.discard", which is marked
 753                 #     for deletion
 754                 #   - one unreachable commit, "cruft.old", which would be marked
 755                 #     for deletion, but is rescued as an extra cruft tip
 756                 #   - one unreachable commit, "cruft.new", which is not marked
 757                 #     for deletion
 758                 test_commit base &&
 759                 git branch -M main &&
 760
 761                 git checkout --orphan discard &&
 762                 git rm -fr . &&
 763                 test_commit --no-tag cruft.discard &&
 764
 765                 git checkout --orphan old &&
 766                 git rm -fr . &&
 767                 test_commit --no-tag cruft.old &&
 768                 cruft_old="$(git rev-parse HEAD)" &&
 769
 770                 git checkout --orphan new &&
 771                 git rm -fr . &&
 772                 test_commit --no-tag cruft.new &&
 773                 cruft_new="$(git rev-parse HEAD)" &&
 774
 775                 git checkout main &&
 776                 git branch -D discard old new &&
 777                 git reflog expire --all --expire=all &&
 778
 779                 # mark cruft.old with an mtime that is many minutes
 780                 # older than the expiration period, and mark cruft.new
 781                 # with an mtime that is in the future (and thus not
 782                 # eligible for pruning).
 783                 test-tool chmtime -2000 "$objdir/$(test_oid_to_path $cruft_old)" &&
 784                 test-tool chmtime +1000 "$objdir/$(test_oid_to_path $cruft_new)" &&
 785
 786                 # Write the list of cruft objects we expect to
 787                 # accumulate, which is comprised of everything reachable
 788                 # from cruft.old and cruft.new, but not cruft.discard.
 789                 git rev-list --objects --no-object-names \
 790                         $cruft_old $cruft_new >cruft.raw &&
 791                 sort cruft.raw >cruft.expect &&
 792
 793                 # Write the script to list extra tips, which are limited
 794                 # to cruft.old, in this case.
 795                 write_script extra-tips <<-EOF &&
 796                 echo $cruft_old
 797                 EOF
 798                 git config gc.recentObjectsHook ./extra-tips &&
 799
 800                 git repack --cruft --cruft-expiration=now -d &&
 801
 802                 mtimes="$(ls .git/objects/pack/pack-*.mtimes)" &&
 803                 git show-index <${mtimes%.mtimes}.idx >cruft &&
 804                 cut -d" " -f2 cruft | sort >cruft.actual &&
 805                 test_cmp cruft.expect cruft.actual &&
 806
 807                 # Ensure that the "old" objects are removed after
 808                 # dropping the gc.recentObjectsHook hook.
 809                 git config --unset gc.recentObjectsHook &&
 810                 git repack --cruft --cruft-expiration=now -d &&
 811
 812                 mtimes="$(ls .git/objects/pack/pack-*.mtimes)" &&
 813                 git show-index <${mtimes%.mtimes}.idx >cruft &&
 814                 cut -d" " -f2 cruft | sort >cruft.actual &&
 815
 816                 git rev-list --objects --no-object-names $cruft_new >cruft.raw &&
 817                 cp cruft.expect cruft.old &&
 818                 sort cruft.raw >cruft.expect &&
 819                 test_cmp cruft.expect cruft.actual &&
 820
 821                 # ensure objects which are no longer in the cruft pack were
 822                 # removed from the repository
 823                 for object in $(comm -13 cruft.expect cruft.old)
 824                 do
 825                         test_must_fail git cat-file -t $object || return 1
 826                 done
 827         )
 828 '
 829
 830 test_expect_success 'multi-valued gc.recentObjectsHook' '
 831         git init repo &&
 832         test_when_finished "rm -fr repo" &&
 833         (
 834                 cd repo &&
 835
 836                 test_commit base &&
 837                 git branch -M main &&
 838
 839                 git checkout --orphan cruft.a &&
 840                 git rm -fr . &&
 841                 test_commit --no-tag cruft.a &&
 842                 cruft_a="$(git rev-parse HEAD)" &&
 843
 844                 git checkout --orphan cruft.b &&
 845                 git rm -fr . &&
 846                 test_commit --no-tag cruft.b &&
 847                 cruft_b="$(git rev-parse HEAD)" &&
 848
 849                 git checkout main &&
 850                 git branch -D cruft.a cruft.b &&
 851                 git reflog expire --all --expire=all &&
 852
 853                 echo "echo $cruft_a" | write_script extra-tips.a &&
 854                 echo "echo $cruft_b" | write_script extra-tips.b &&
 855                 echo "false" | write_script extra-tips.c &&
 856
 857                 git rev-list --objects --no-object-names $cruft_a $cruft_b \
 858                         >cruft.raw &&
 859                 sort cruft.raw >cruft.expect &&
 860
 861                 # ensure that each extra cruft tip is saved by its
 862                 # respective hook
 863                 git config --add gc.recentObjectsHook ./extra-tips.a &&
 864                 git config --add gc.recentObjectsHook ./extra-tips.b &&
 865                 git repack --cruft --cruft-expiration=now -d &&
 866
 867                 mtimes="$(ls .git/objects/pack/pack-*.mtimes)" &&
 868                 git show-index <${mtimes%.mtimes}.idx >cruft &&
 869                 cut -d" " -f2 cruft | sort >cruft.actual &&
 870                 test_cmp cruft.expect cruft.actual &&
 871
 872                 # ensure that a dirty exit halts cruft pack generation
 873                 git config --add gc.recentObjectsHook ./extra-tips.c &&
 874                 test_must_fail git repack --cruft --cruft-expiration=now -d 2>err &&
 875                 grep "unable to enumerate additional recent objects" err &&
 876
 877                 # and that the existing cruft pack is left alone
 878                 test_path_is_file "$mtimes"
 879         )
 880 '
 881
 882 test_expect_success 'additional cruft blobs via gc.recentObjectsHook' '
 883         git init repo &&
 884         test_when_finished "rm -fr repo" &&
 885         (
 886                 cd repo &&
 887
 888                 test_commit base &&
 889
 890                 blob=$(echo "unreachable" | git hash-object -w --stdin) &&
 891
 892                 # mark the unreachable blob we wrote above as having
 893                 # aged out of the retention period
 894                 test-tool chmtime -2000 "$objdir/$(test_oid_to_path $blob)" &&
 895
 896                 # Write the script to list extra tips, which is just the
 897                 # extra blob as above.
 898                 write_script extra-tips <<-EOF &&
 899                 echo $blob
 900                 EOF
 901                 git config gc.recentObjectsHook ./extra-tips &&
 902
 903                 git repack --cruft --cruft-expiration=now -d &&
 904
 905                 mtimes="$(ls .git/objects/pack/pack-*.mtimes)" &&
 906                 git show-index <${mtimes%.mtimes}.idx >cruft &&
 907                 cut -d" " -f2 cruft >actual &&
 908                 echo $blob >expect &&
 909                 test_cmp expect actual
 910         )
 911 '
 912
 913 test_done