t/t7900-maintenance.sh

   1 #!/bin/sh
   2
   3 test_description='git maintenance builtin'
   4
   5 . ./test-lib.sh
   6
   7 GIT_TEST_COMMIT_GRAPH=0
   8 GIT_TEST_MULTI_PACK_INDEX=0
   9
  10 test_lazy_prereq XMLLINT '
  11         xmllint --version
  12 '
  13
  14 test_xmllint () {
  15         if test_have_prereq XMLLINT
  16         then
  17                 xmllint --noout "$@"
  18         else
  19                 true
  20         fi
  21 }
  22
  23 test_lazy_prereq SYSTEMD_ANALYZE '
  24         systemd-analyze verify /lib/systemd/system/basic.target
  25 '
  26
  27 test_systemd_analyze_verify () {
  28         if test_have_prereq SYSTEMD_ANALYZE
  29         then
  30                 systemd-analyze verify "$@"
  31         fi
  32 }
  33
  34 test_expect_success 'help text' '
  35         test_expect_code 129 git maintenance -h >actual &&
  36         test_i18ngrep "usage: git maintenance <subcommand>" actual &&
  37         test_expect_code 129 git maintenance barf 2>err &&
  38         test_i18ngrep "unknown subcommand: \`barf'\''" err &&
  39         test_i18ngrep "usage: git maintenance" err &&
  40         test_expect_code 129 git maintenance 2>err &&
  41         test_i18ngrep "error: need a subcommand" err &&
  42         test_i18ngrep "usage: git maintenance" err
  43 '
  44
  45 test_expect_success 'run [--auto|--quiet]' '
  46         GIT_TRACE2_EVENT="$(pwd)/run-no-auto.txt" \
  47                 git maintenance run 2>/dev/null &&
  48         GIT_TRACE2_EVENT="$(pwd)/run-auto.txt" \
  49                 git maintenance run --auto 2>/dev/null &&
  50         GIT_TRACE2_EVENT="$(pwd)/run-no-quiet.txt" \
  51                 git maintenance run --no-quiet 2>/dev/null &&
  52         test_subcommand git gc --quiet <run-no-auto.txt &&
  53         test_subcommand ! git gc --auto --quiet <run-auto.txt &&
  54         test_subcommand git gc --no-quiet <run-no-quiet.txt
  55 '
  56
  57 test_expect_success 'maintenance.auto config option' '
  58         GIT_TRACE2_EVENT="$(pwd)/default" git commit --quiet --allow-empty -m 1 &&
  59         test_subcommand git maintenance run --auto --quiet <default &&
  60         GIT_TRACE2_EVENT="$(pwd)/true" \
  61                 git -c maintenance.auto=true \
  62                 commit --quiet --allow-empty -m 2 &&
  63         test_subcommand git maintenance run --auto --quiet  <true &&
  64         GIT_TRACE2_EVENT="$(pwd)/false" \
  65                 git -c maintenance.auto=false \
  66                 commit --quiet --allow-empty -m 3 &&
  67         test_subcommand ! git maintenance run --auto --quiet  <false
  68 '
  69
  70 test_expect_success 'maintenance.<task>.enabled' '
  71         git config maintenance.gc.enabled false &&
  72         git config maintenance.commit-graph.enabled true &&
  73         GIT_TRACE2_EVENT="$(pwd)/run-config.txt" git maintenance run 2>err &&
  74         test_subcommand ! git gc --quiet <run-config.txt &&
  75         test_subcommand git commit-graph write --split --reachable --no-progress <run-config.txt
  76 '
  77
  78 test_expect_success 'run --task=<task>' '
  79         GIT_TRACE2_EVENT="$(pwd)/run-commit-graph.txt" \
  80                 git maintenance run --task=commit-graph 2>/dev/null &&
  81         GIT_TRACE2_EVENT="$(pwd)/run-gc.txt" \
  82                 git maintenance run --task=gc 2>/dev/null &&
  83         GIT_TRACE2_EVENT="$(pwd)/run-commit-graph.txt" \
  84                 git maintenance run --task=commit-graph 2>/dev/null &&
  85         GIT_TRACE2_EVENT="$(pwd)/run-both.txt" \
  86                 git maintenance run --task=commit-graph --task=gc 2>/dev/null &&
  87         test_subcommand ! git gc --quiet <run-commit-graph.txt &&
  88         test_subcommand git gc --quiet <run-gc.txt &&
  89         test_subcommand git gc --quiet <run-both.txt &&
  90         test_subcommand git commit-graph write --split --reachable --no-progress <run-commit-graph.txt &&
  91         test_subcommand ! git commit-graph write --split --reachable --no-progress <run-gc.txt &&
  92         test_subcommand git commit-graph write --split --reachable --no-progress <run-both.txt
  93 '
  94
  95 test_expect_success 'core.commitGraph=false prevents write process' '
  96         GIT_TRACE2_EVENT="$(pwd)/no-commit-graph.txt" \
  97                 git -c core.commitGraph=false maintenance run \
  98                 --task=commit-graph 2>/dev/null &&
  99         test_subcommand ! git commit-graph write --split --reachable --no-progress \
 100                 <no-commit-graph.txt
 101 '
 102
 103 test_expect_success 'commit-graph auto condition' '
 104         COMMAND="maintenance run --task=commit-graph --auto --quiet" &&
 105
 106         GIT_TRACE2_EVENT="$(pwd)/cg-no.txt" \
 107                 git -c maintenance.commit-graph.auto=1 $COMMAND &&
 108         GIT_TRACE2_EVENT="$(pwd)/cg-negative-means-yes.txt" \
 109                 git -c maintenance.commit-graph.auto="-1" $COMMAND &&
 110
 111         test_commit first &&
 112
 113         GIT_TRACE2_EVENT="$(pwd)/cg-zero-means-no.txt" \
 114                 git -c maintenance.commit-graph.auto=0 $COMMAND &&
 115         GIT_TRACE2_EVENT="$(pwd)/cg-one-satisfied.txt" \
 116                 git -c maintenance.commit-graph.auto=1 $COMMAND &&
 117
 118         git commit --allow-empty -m "second" &&
 119         git commit --allow-empty -m "third" &&
 120
 121         GIT_TRACE2_EVENT="$(pwd)/cg-two-satisfied.txt" \
 122                 git -c maintenance.commit-graph.auto=2 $COMMAND &&
 123
 124         COMMIT_GRAPH_WRITE="git commit-graph write --split --reachable --no-progress" &&
 125         test_subcommand ! $COMMIT_GRAPH_WRITE <cg-no.txt &&
 126         test_subcommand $COMMIT_GRAPH_WRITE <cg-negative-means-yes.txt &&
 127         test_subcommand ! $COMMIT_GRAPH_WRITE <cg-zero-means-no.txt &&
 128         test_subcommand $COMMIT_GRAPH_WRITE <cg-one-satisfied.txt &&
 129         test_subcommand $COMMIT_GRAPH_WRITE <cg-two-satisfied.txt
 130 '
 131
 132 test_expect_success 'run --task=bogus' '
 133         test_must_fail git maintenance run --task=bogus 2>err &&
 134         test_i18ngrep "is not a valid task" err
 135 '
 136
 137 test_expect_success 'run --task duplicate' '
 138         test_must_fail git maintenance run --task=gc --task=gc 2>err &&
 139         test_i18ngrep "cannot be selected multiple times" err
 140 '
 141
 142 test_expect_success 'run --task=prefetch with no remotes' '
 143         git maintenance run --task=prefetch 2>err &&
 144         test_must_be_empty err
 145 '
 146
 147 test_expect_success 'prefetch multiple remotes' '
 148         git clone . clone1 &&
 149         git clone . clone2 &&
 150         git remote add remote1 "file://$(pwd)/clone1" &&
 151         git remote add remote2 "file://$(pwd)/clone2" &&
 152         git -C clone1 switch -c one &&
 153         git -C clone2 switch -c two &&
 154         test_commit -C clone1 one &&
 155         test_commit -C clone2 two &&
 156         GIT_TRACE2_EVENT="$(pwd)/run-prefetch.txt" git maintenance run --task=prefetch 2>/dev/null &&
 157         fetchargs="--prefetch --prune --no-tags --no-write-fetch-head --recurse-submodules=no --quiet" &&
 158         test_subcommand git fetch remote1 $fetchargs <run-prefetch.txt &&
 159         test_subcommand git fetch remote2 $fetchargs <run-prefetch.txt &&
 160         test_path_is_missing .git/refs/remotes &&
 161         git log prefetch/remotes/remote1/one &&
 162         git log prefetch/remotes/remote2/two &&
 163         git fetch --all &&
 164         test_cmp_rev refs/remotes/remote1/one refs/prefetch/remotes/remote1/one &&
 165         test_cmp_rev refs/remotes/remote2/two refs/prefetch/remotes/remote2/two &&
 166
 167         git log --oneline --decorate --all >log &&
 168         ! grep "prefetch" log &&
 169
 170         test_when_finished git config --unset remote.remote1.skipFetchAll &&
 171         git config remote.remote1.skipFetchAll true &&
 172         GIT_TRACE2_EVENT="$(pwd)/skip-remote1.txt" git maintenance run --task=prefetch 2>/dev/null &&
 173         test_subcommand ! git fetch remote1 $fetchargs <skip-remote1.txt &&
 174         test_subcommand git fetch remote2 $fetchargs <skip-remote1.txt
 175 '
 176
 177 test_expect_success 'loose-objects task' '
 178         # Repack everything so we know the state of the object dir
 179         git repack -adk &&
 180
 181         # Hack to stop maintenance from running during "git commit"
 182         echo in use >.git/objects/maintenance.lock &&
 183
 184         # Assuming that "git commit" creates at least one loose object
 185         test_commit create-loose-object &&
 186         rm .git/objects/maintenance.lock &&
 187
 188         ls .git/objects >obj-dir-before &&
 189         test_file_not_empty obj-dir-before &&
 190         ls .git/objects/pack/*.pack >packs-before &&
 191         test_line_count = 1 packs-before &&
 192
 193         # The first run creates a pack-file
 194         # but does not delete loose objects.
 195         git maintenance run --task=loose-objects &&
 196         ls .git/objects >obj-dir-between &&
 197         test_cmp obj-dir-before obj-dir-between &&
 198         ls .git/objects/pack/*.pack >packs-between &&
 199         test_line_count = 2 packs-between &&
 200         ls .git/objects/pack/loose-*.pack >loose-packs &&
 201         test_line_count = 1 loose-packs &&
 202
 203         # The second run deletes loose objects
 204         # but does not create a pack-file.
 205         git maintenance run --task=loose-objects &&
 206         ls .git/objects >obj-dir-after &&
 207         cat >expect <<-\EOF &&
 208         info
 209         pack
 210         EOF
 211         test_cmp expect obj-dir-after &&
 212         ls .git/objects/pack/*.pack >packs-after &&
 213         test_cmp packs-between packs-after
 214 '
 215
 216 test_expect_success 'maintenance.loose-objects.auto' '
 217         git repack -adk &&
 218         GIT_TRACE2_EVENT="$(pwd)/trace-lo1.txt" \
 219                 git -c maintenance.loose-objects.auto=1 maintenance \
 220                 run --auto --task=loose-objects 2>/dev/null &&
 221         test_subcommand ! git prune-packed --quiet <trace-lo1.txt &&
 222         printf data-A | git hash-object -t blob --stdin -w &&
 223         GIT_TRACE2_EVENT="$(pwd)/trace-loA" \
 224                 git -c maintenance.loose-objects.auto=2 \
 225                 maintenance run --auto --task=loose-objects 2>/dev/null &&
 226         test_subcommand ! git prune-packed --quiet <trace-loA &&
 227         printf data-B | git hash-object -t blob --stdin -w &&
 228         GIT_TRACE2_EVENT="$(pwd)/trace-loB" \
 229                 git -c maintenance.loose-objects.auto=2 \
 230                 maintenance run --auto --task=loose-objects 2>/dev/null &&
 231         test_subcommand git prune-packed --quiet <trace-loB &&
 232         GIT_TRACE2_EVENT="$(pwd)/trace-loC" \
 233                 git -c maintenance.loose-objects.auto=2 \
 234                 maintenance run --auto --task=loose-objects 2>/dev/null &&
 235         test_subcommand git prune-packed --quiet <trace-loC
 236 '
 237
 238 test_expect_success 'incremental-repack task' '
 239         packDir=.git/objects/pack &&
 240         for i in $(test_seq 1 5)
 241         do
 242                 test_commit $i || return 1
 243         done &&
 244
 245         # Create three disjoint pack-files with size BIG, small, small.
 246         echo HEAD~2 | git pack-objects --revs $packDir/test-1 &&
 247         test_tick &&
 248         git pack-objects --revs $packDir/test-2 <<-\EOF &&
 249         HEAD~1
 250         ^HEAD~2
 251         EOF
 252         test_tick &&
 253         git pack-objects --revs $packDir/test-3 <<-\EOF &&
 254         HEAD
 255         ^HEAD~1
 256         EOF
 257
 258         # Delete refs that have not been repacked in these packs.
 259         git for-each-ref --format="delete %(refname)" \
 260                 refs/prefetch refs/tags refs/remotes >refs &&
 261         git update-ref --stdin <refs &&
 262
 263         # Replace the object directory with this pack layout.
 264         rm -f $packDir/pack-* &&
 265         rm -f $packDir/loose-* &&
 266         ls $packDir/*.pack >packs-before &&
 267         test_line_count = 3 packs-before &&
 268
 269         # make sure we do not have any broken refs that were
 270         # missed in the deletion above
 271         git for-each-ref &&
 272
 273         # the job repacks the two into a new pack, but does not
 274         # delete the old ones.
 275         git maintenance run --task=incremental-repack &&
 276         ls $packDir/*.pack >packs-between &&
 277         test_line_count = 4 packs-between &&
 278
 279         # the job deletes the two old packs, and does not write
 280         # a new one because the batch size is not high enough to
 281         # pack the largest pack-file.
 282         git maintenance run --task=incremental-repack &&
 283         ls .git/objects/pack/*.pack >packs-after &&
 284         test_line_count = 2 packs-after
 285 '
 286
 287 test_expect_success EXPENSIVE 'incremental-repack 2g limit' '
 288         test_config core.compression 0 &&
 289
 290         for i in $(test_seq 1 5)
 291         do
 292                 test-tool genrandom foo$i $((512 * 1024 * 1024 + 1)) >>big ||
 293                 return 1
 294         done &&
 295         git add big &&
 296         git commit -qm "Add big file (1)" &&
 297
 298         # ensure any possible loose objects are in a pack-file
 299         git maintenance run --task=loose-objects &&
 300
 301         rm big &&
 302         for i in $(test_seq 6 10)
 303         do
 304                 test-tool genrandom foo$i $((512 * 1024 * 1024 + 1)) >>big ||
 305                 return 1
 306         done &&
 307         git add big &&
 308         git commit -qm "Add big file (2)" &&
 309
 310         # ensure any possible loose objects are in a pack-file
 311         git maintenance run --task=loose-objects &&
 312
 313         # Now run the incremental-repack task and check the batch-size
 314         GIT_TRACE2_EVENT="$(pwd)/run-2g.txt" git maintenance run \
 315                 --task=incremental-repack 2>/dev/null &&
 316         test_subcommand git multi-pack-index repack \
 317                  --no-progress --batch-size=2147483647 <run-2g.txt
 318 '
 319
 320 run_incremental_repack_and_verify () {
 321         test_commit A &&
 322         git repack -adk &&
 323         git multi-pack-index write &&
 324         GIT_TRACE2_EVENT="$(pwd)/midx-init.txt" git \
 325                 -c maintenance.incremental-repack.auto=1 \
 326                 maintenance run --auto --task=incremental-repack 2>/dev/null &&
 327         test_subcommand ! git multi-pack-index write --no-progress <midx-init.txt &&
 328         test_commit B &&
 329         git pack-objects --revs .git/objects/pack/pack <<-\EOF &&
 330         HEAD
 331         ^HEAD~1
 332         EOF
 333         GIT_TRACE2_EVENT=$(pwd)/trace-A git \
 334                 -c maintenance.incremental-repack.auto=2 \
 335                 maintenance run --auto --task=incremental-repack 2>/dev/null &&
 336         test_subcommand ! git multi-pack-index write --no-progress <trace-A &&
 337         test_commit C &&
 338         git pack-objects --revs .git/objects/pack/pack <<-\EOF &&
 339         HEAD
 340         ^HEAD~1
 341         EOF
 342         GIT_TRACE2_EVENT=$(pwd)/trace-B git \
 343                 -c maintenance.incremental-repack.auto=2 \
 344                 maintenance run --auto --task=incremental-repack 2>/dev/null &&
 345         test_subcommand git multi-pack-index write --no-progress <trace-B
 346 }
 347
 348 test_expect_success 'maintenance.incremental-repack.auto' '
 349         rm -rf incremental-repack-true &&
 350         git init incremental-repack-true &&
 351         (
 352                 cd incremental-repack-true &&
 353                 git config core.multiPackIndex true &&
 354                 run_incremental_repack_and_verify
 355         )
 356 '
 357
 358 test_expect_success 'maintenance.incremental-repack.auto (when config is unset)' '
 359         rm -rf incremental-repack-unset &&
 360         git init incremental-repack-unset &&
 361         (
 362                 cd incremental-repack-unset &&
 363                 test_unconfig core.multiPackIndex &&
 364                 run_incremental_repack_and_verify
 365         )
 366 '
 367
 368 test_expect_success 'pack-refs task' '
 369         for n in $(test_seq 1 5)
 370         do
 371                 git branch -f to-pack/$n HEAD || return 1
 372         done &&
 373         GIT_TRACE2_EVENT="$(pwd)/pack-refs.txt" \
 374                 git maintenance run --task=pack-refs &&
 375         test_subcommand git pack-refs --all --prune <pack-refs.txt
 376 '
 377
 378 test_expect_success '--auto and --schedule incompatible' '
 379         test_must_fail git maintenance run --auto --schedule=daily 2>err &&
 380         test_i18ngrep "at most one" err
 381 '
 382
 383 test_expect_success 'invalid --schedule value' '
 384         test_must_fail git maintenance run --schedule=annually 2>err &&
 385         test_i18ngrep "unrecognized --schedule" err
 386 '
 387
 388 test_expect_success '--schedule inheritance weekly -> daily -> hourly' '
 389         git config maintenance.loose-objects.enabled true &&
 390         git config maintenance.loose-objects.schedule hourly &&
 391         git config maintenance.commit-graph.enabled true &&
 392         git config maintenance.commit-graph.schedule daily &&
 393         git config maintenance.incremental-repack.enabled true &&
 394         git config maintenance.incremental-repack.schedule weekly &&
 395
 396         GIT_TRACE2_EVENT="$(pwd)/hourly.txt" \
 397                 git maintenance run --schedule=hourly 2>/dev/null &&
 398         test_subcommand git prune-packed --quiet <hourly.txt &&
 399         test_subcommand ! git commit-graph write --split --reachable \
 400                 --no-progress <hourly.txt &&
 401         test_subcommand ! git multi-pack-index write --no-progress <hourly.txt &&
 402
 403         GIT_TRACE2_EVENT="$(pwd)/daily.txt" \
 404                 git maintenance run --schedule=daily 2>/dev/null &&
 405         test_subcommand git prune-packed --quiet <daily.txt &&
 406         test_subcommand git commit-graph write --split --reachable \
 407                 --no-progress <daily.txt &&
 408         test_subcommand ! git multi-pack-index write --no-progress <daily.txt &&
 409
 410         GIT_TRACE2_EVENT="$(pwd)/weekly.txt" \
 411                 git maintenance run --schedule=weekly 2>/dev/null &&
 412         test_subcommand git prune-packed --quiet <weekly.txt &&
 413         test_subcommand git commit-graph write --split --reachable \
 414                 --no-progress <weekly.txt &&
 415         test_subcommand git multi-pack-index write --no-progress <weekly.txt
 416 '
 417
 418 test_expect_success 'maintenance.strategy inheritance' '
 419         for task in commit-graph loose-objects incremental-repack
 420         do
 421                 git config --unset maintenance.$task.schedule || return 1
 422         done &&
 423
 424         test_when_finished git config --unset maintenance.strategy &&
 425         git config maintenance.strategy incremental &&
 426
 427         GIT_TRACE2_EVENT="$(pwd)/incremental-hourly.txt" \
 428                 git maintenance run --schedule=hourly --quiet &&
 429         GIT_TRACE2_EVENT="$(pwd)/incremental-daily.txt" \
 430                 git maintenance run --schedule=daily --quiet &&
 431         GIT_TRACE2_EVENT="$(pwd)/incremental-weekly.txt" \
 432                 git maintenance run --schedule=weekly --quiet &&
 433
 434         test_subcommand git commit-graph write --split --reachable \
 435                 --no-progress <incremental-hourly.txt &&
 436         test_subcommand ! git prune-packed --quiet <incremental-hourly.txt &&
 437         test_subcommand ! git multi-pack-index write --no-progress \
 438                 <incremental-hourly.txt &&
 439         test_subcommand ! git pack-refs --all --prune \
 440                 <incremental-hourly.txt &&
 441
 442         test_subcommand git commit-graph write --split --reachable \
 443                 --no-progress <incremental-daily.txt &&
 444         test_subcommand git prune-packed --quiet <incremental-daily.txt &&
 445         test_subcommand git multi-pack-index write --no-progress \
 446                 <incremental-daily.txt &&
 447         test_subcommand ! git pack-refs --all --prune \
 448                 <incremental-daily.txt &&
 449
 450         test_subcommand git commit-graph write --split --reachable \
 451                 --no-progress <incremental-weekly.txt &&
 452         test_subcommand git prune-packed --quiet <incremental-weekly.txt &&
 453         test_subcommand git multi-pack-index write --no-progress \
 454                 <incremental-weekly.txt &&
 455         test_subcommand git pack-refs --all --prune \
 456                 <incremental-weekly.txt &&
 457
 458         # Modify defaults
 459         git config maintenance.commit-graph.schedule daily &&
 460         git config maintenance.loose-objects.schedule hourly &&
 461         git config maintenance.incremental-repack.enabled false &&
 462
 463         GIT_TRACE2_EVENT="$(pwd)/modified-hourly.txt" \
 464                 git maintenance run --schedule=hourly --quiet &&
 465         GIT_TRACE2_EVENT="$(pwd)/modified-daily.txt" \
 466                 git maintenance run --schedule=daily --quiet &&
 467
 468         test_subcommand ! git commit-graph write --split --reachable \
 469                 --no-progress <modified-hourly.txt &&
 470         test_subcommand git prune-packed --quiet <modified-hourly.txt &&
 471         test_subcommand ! git multi-pack-index write --no-progress \
 472                 <modified-hourly.txt &&
 473
 474         test_subcommand git commit-graph write --split --reachable \
 475                 --no-progress <modified-daily.txt &&
 476         test_subcommand git prune-packed --quiet <modified-daily.txt &&
 477         test_subcommand ! git multi-pack-index write --no-progress \
 478                 <modified-daily.txt
 479 '
 480
 481 test_expect_success 'register and unregister' '
 482         test_when_finished git config --global --unset-all maintenance.repo &&
 483
 484         test_must_fail git maintenance unregister 2>err &&
 485         grep "is not registered" err &&
 486         git maintenance unregister --force &&
 487
 488         git config --global --add maintenance.repo /existing1 &&
 489         git config --global --add maintenance.repo /existing2 &&
 490         git config --global --get-all maintenance.repo >before &&
 491
 492         git maintenance register &&
 493         test_cmp_config false maintenance.auto &&
 494         git config --global --get-all maintenance.repo >between &&
 495         cp before expect &&
 496         pwd >>expect &&
 497         test_cmp expect between &&
 498
 499         git maintenance unregister &&
 500         git config --global --get-all maintenance.repo >actual &&
 501         test_cmp before actual &&
 502
 503         git config --file ./other --add maintenance.repo /existing1 &&
 504         git config --file ./other --add maintenance.repo /existing2 &&
 505         git config --file ./other --get-all maintenance.repo >before &&
 506
 507         git maintenance register --config-file ./other &&
 508         test_cmp_config false maintenance.auto &&
 509         git config --file ./other --get-all maintenance.repo >between &&
 510         cp before expect &&
 511         pwd >>expect &&
 512         test_cmp expect between &&
 513
 514         git maintenance unregister --config-file ./other &&
 515         git config --file ./other --get-all maintenance.repo >actual &&
 516         test_cmp before actual &&
 517
 518         test_must_fail git maintenance unregister 2>err &&
 519         grep "is not registered" err &&
 520         git maintenance unregister --force &&
 521
 522         test_must_fail git maintenance unregister --config-file ./other 2>err &&
 523         grep "is not registered" err &&
 524         git maintenance unregister --config-file ./other --force
 525 '
 526
 527 test_expect_success !MINGW 'register and unregister with regex metacharacters' '
 528         META="a+b*c" &&
 529         git init "$META" &&
 530         git -C "$META" maintenance register &&
 531         git config --get-all --show-origin maintenance.repo &&
 532         git config --get-all --global --fixed-value \
 533                 maintenance.repo "$(pwd)/$META" &&
 534         git -C "$META" maintenance unregister &&
 535         test_must_fail git config --get-all --global --fixed-value \
 536                 maintenance.repo "$(pwd)/$META"
 537 '
 538
 539 test_expect_success 'start --scheduler=<scheduler>' '
 540         test_expect_code 129 git maintenance start --scheduler=foo 2>err &&
 541         test_i18ngrep "unrecognized --scheduler argument" err &&
 542
 543         test_expect_code 129 git maintenance start --no-scheduler 2>err &&
 544         test_i18ngrep "unknown option" err &&
 545
 546         test_expect_code 128 \
 547                 env GIT_TEST_MAINT_SCHEDULER="launchctl:true,schtasks:true" \
 548                 git maintenance start --scheduler=crontab 2>err &&
 549         test_i18ngrep "fatal: crontab scheduler is not available" err
 550 '
 551
 552 test_expect_success 'start from empty cron table' '
 553         GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab cron.txt" git maintenance start --scheduler=crontab &&
 554
 555         # start registers the repo
 556         git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 557
 558         grep "for-each-repo --config=maintenance.repo maintenance run --schedule=daily" cron.txt &&
 559         grep "for-each-repo --config=maintenance.repo maintenance run --schedule=hourly" cron.txt &&
 560         grep "for-each-repo --config=maintenance.repo maintenance run --schedule=weekly" cron.txt
 561 '
 562
 563 test_expect_success 'stop from existing schedule' '
 564         GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab cron.txt" git maintenance stop &&
 565
 566         # stop does not unregister the repo
 567         git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 568
 569         # Operation is idempotent
 570         GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab cron.txt" git maintenance stop &&
 571         test_must_be_empty cron.txt
 572 '
 573
 574 test_expect_success 'start preserves existing schedule' '
 575         echo "Important information!" >cron.txt &&
 576         GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab cron.txt" git maintenance start --scheduler=crontab &&
 577         grep "Important information!" cron.txt
 578 '
 579
 580 test_expect_success 'magic markers are correct' '
 581         grep "GIT MAINTENANCE SCHEDULE" cron.txt >actual &&
 582         cat >expect <<-\EOF &&
 583         # BEGIN GIT MAINTENANCE SCHEDULE
 584         # END GIT MAINTENANCE SCHEDULE
 585         EOF
 586         test_cmp actual expect
 587 '
 588
 589 test_expect_success 'stop preserves surrounding schedule' '
 590         echo "Crucial information!" >>cron.txt &&
 591         GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab cron.txt" git maintenance stop &&
 592         grep "Important information!" cron.txt &&
 593         grep "Crucial information!" cron.txt
 594 '
 595
 596 test_expect_success 'start and stop macOS maintenance' '
 597         # ensure $HOME can be compared against hook arguments on all platforms
 598         pfx=$(cd "$HOME" && pwd) &&
 599
 600         write_script print-args <<-\EOF &&
 601         echo $* | sed "s:gui/[0-9][0-9]*:gui/[UID]:" >>args
 602         EOF
 603
 604         rm -f args &&
 605         GIT_TEST_MAINT_SCHEDULER=launchctl:./print-args git maintenance start --scheduler=launchctl &&
 606
 607         # start registers the repo
 608         git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 609
 610         ls "$HOME/Library/LaunchAgents" >actual &&
 611         cat >expect <<-\EOF &&
 612         org.git-scm.git.daily.plist
 613         org.git-scm.git.hourly.plist
 614         org.git-scm.git.weekly.plist
 615         EOF
 616         test_cmp expect actual &&
 617
 618         rm -f expect &&
 619         for frequency in hourly daily weekly
 620         do
 621                 PLIST="$pfx/Library/LaunchAgents/org.git-scm.git.$frequency.plist" &&
 622                 test_xmllint "$PLIST" &&
 623                 grep schedule=$frequency "$PLIST" &&
 624                 echo "bootout gui/[UID] $PLIST" >>expect &&
 625                 echo "bootstrap gui/[UID] $PLIST" >>expect || return 1
 626         done &&
 627         test_cmp expect args &&
 628
 629         rm -f args &&
 630         GIT_TEST_MAINT_SCHEDULER=launchctl:./print-args git maintenance stop &&
 631
 632         # stop does not unregister the repo
 633         git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 634
 635         printf "bootout gui/[UID] $pfx/Library/LaunchAgents/org.git-scm.git.%s.plist\n" \
 636                 hourly daily weekly >expect &&
 637         test_cmp expect args &&
 638         ls "$HOME/Library/LaunchAgents" >actual &&
 639         test_line_count = 0 actual
 640 '
 641
 642 test_expect_success 'use launchctl list to prevent extra work' '
 643         # ensure we are registered
 644         GIT_TEST_MAINT_SCHEDULER=launchctl:./print-args git maintenance start --scheduler=launchctl &&
 645
 646         # do it again on a fresh args file
 647         rm -f args &&
 648         GIT_TEST_MAINT_SCHEDULER=launchctl:./print-args git maintenance start --scheduler=launchctl &&
 649
 650         ls "$HOME/Library/LaunchAgents" >actual &&
 651         cat >expect <<-\EOF &&
 652         list org.git-scm.git.hourly
 653         list org.git-scm.git.daily
 654         list org.git-scm.git.weekly
 655         EOF
 656         test_cmp expect args
 657 '
 658
 659 test_expect_success 'start and stop Windows maintenance' '
 660         write_script print-args <<-\EOF &&
 661         echo $* >>args
 662         while test $# -gt 0
 663         do
 664                 case "$1" in
 665                 /xml) shift; xmlfile=$1; break ;;
 666                 *) shift ;;
 667                 esac
 668         done
 669         test -z "$xmlfile" || cp "$xmlfile" "$xmlfile.xml"
 670         EOF
 671
 672         rm -f args &&
 673         GIT_TEST_MAINT_SCHEDULER="schtasks:./print-args" git maintenance start --scheduler=schtasks &&
 674
 675         # start registers the repo
 676         git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 677
 678         for frequency in hourly daily weekly
 679         do
 680                 grep "/create /tn Git Maintenance ($frequency) /f /xml" args &&
 681                 file=$(ls .git/schedule_${frequency}*.xml) &&
 682                 test_xmllint "$file" || return 1
 683         done &&
 684
 685         rm -f args &&
 686         GIT_TEST_MAINT_SCHEDULER="schtasks:./print-args" git maintenance stop &&
 687
 688         # stop does not unregister the repo
 689         git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 690
 691         printf "/delete /tn Git Maintenance (%s) /f\n" \
 692                 hourly daily weekly >expect &&
 693         test_cmp expect args
 694 '
 695
 696 test_expect_success 'start and stop Linux/systemd maintenance' '
 697         write_script print-args <<-\EOF &&
 698         printf "%s\n" "$*" >>args
 699         EOF
 700
 701         XDG_CONFIG_HOME="$PWD" &&
 702         export XDG_CONFIG_HOME &&
 703         rm -f args &&
 704         GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args" git maintenance start --scheduler=systemd-timer &&
 705
 706         # start registers the repo
 707         git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 708
 709         test_systemd_analyze_verify "systemd/user/git-maintenance@.service" &&
 710
 711         printf -- "--user enable --now git-maintenance@%s.timer\n" hourly daily weekly >expect &&
 712         test_cmp expect args &&
 713
 714         rm -f args &&
 715         GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args" git maintenance stop &&
 716
 717         # stop does not unregister the repo
 718         git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 719
 720         test_path_is_missing "systemd/user/git-maintenance@.timer" &&
 721         test_path_is_missing "systemd/user/git-maintenance@.service" &&
 722
 723         printf -- "--user disable --now git-maintenance@%s.timer\n" hourly daily weekly >expect &&
 724         test_cmp expect args
 725 '
 726
 727 test_expect_success 'start and stop when several schedulers are available' '
 728         write_script print-args <<-\EOF &&
 729         printf "%s\n" "$*" | sed "s:gui/[0-9][0-9]*:gui/[UID]:; s:\(schtasks /create .* /xml\).*:\1:;" >>args
 730         EOF
 731
 732         rm -f args &&
 733         GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args systemctl,launchctl:./print-args launchctl,schtasks:./print-args schtasks" git maintenance start --scheduler=systemd-timer &&
 734         printf "launchctl bootout gui/[UID] $pfx/Library/LaunchAgents/org.git-scm.git.%s.plist\n" \
 735                 hourly daily weekly >expect &&
 736         printf "schtasks /delete /tn Git Maintenance (%s) /f\n" \
 737                 hourly daily weekly >>expect &&
 738         printf -- "systemctl --user enable --now git-maintenance@%s.timer\n" hourly daily weekly >>expect &&
 739         test_cmp expect args &&
 740
 741         rm -f args &&
 742         GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args systemctl,launchctl:./print-args launchctl,schtasks:./print-args schtasks" git maintenance start --scheduler=launchctl &&
 743         printf -- "systemctl --user disable --now git-maintenance@%s.timer\n" hourly daily weekly >expect &&
 744         printf "schtasks /delete /tn Git Maintenance (%s) /f\n" \
 745                 hourly daily weekly >>expect &&
 746         for frequency in hourly daily weekly
 747         do
 748                 PLIST="$pfx/Library/LaunchAgents/org.git-scm.git.$frequency.plist" &&
 749                 echo "launchctl bootout gui/[UID] $PLIST" >>expect &&
 750                 echo "launchctl bootstrap gui/[UID] $PLIST" >>expect || return 1
 751         done &&
 752         test_cmp expect args &&
 753
 754         rm -f args &&
 755         GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args systemctl,launchctl:./print-args launchctl,schtasks:./print-args schtasks" git maintenance start --scheduler=schtasks &&
 756         printf -- "systemctl --user disable --now git-maintenance@%s.timer\n" hourly daily weekly >expect &&
 757         printf "launchctl bootout gui/[UID] $pfx/Library/LaunchAgents/org.git-scm.git.%s.plist\n" \
 758                 hourly daily weekly >>expect &&
 759         printf "schtasks /create /tn Git Maintenance (%s) /f /xml\n" \
 760                 hourly daily weekly >>expect &&
 761         test_cmp expect args &&
 762
 763         rm -f args &&
 764         GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args systemctl,launchctl:./print-args launchctl,schtasks:./print-args schtasks" git maintenance stop &&
 765         printf -- "systemctl --user disable --now git-maintenance@%s.timer\n" hourly daily weekly >expect &&
 766         printf "launchctl bootout gui/[UID] $pfx/Library/LaunchAgents/org.git-scm.git.%s.plist\n" \
 767                 hourly daily weekly >>expect &&
 768         printf "schtasks /delete /tn Git Maintenance (%s) /f\n" \
 769                 hourly daily weekly >>expect &&
 770         test_cmp expect args
 771 '
 772
 773 test_expect_success 'register preserves existing strategy' '
 774         git config maintenance.strategy none &&
 775         git maintenance register &&
 776         test_config maintenance.strategy none &&
 777         git config --unset maintenance.strategy &&
 778         git maintenance register &&
 779         test_config maintenance.strategy incremental
 780 '
 781
 782 test_expect_success 'fails when running outside of a repository' '
 783         nongit test_must_fail git maintenance run &&
 784         nongit test_must_fail git maintenance stop &&
 785         nongit test_must_fail git maintenance start &&
 786         nongit test_must_fail git maintenance register &&
 787         nongit test_must_fail git maintenance unregister
 788 '
 789
 790 test_expect_success 'register and unregister bare repo' '
 791         test_when_finished "git config --global --unset-all maintenance.repo || :" &&
 792         test_might_fail git config --global --unset-all maintenance.repo &&
 793         git init --bare barerepo &&
 794         (
 795                 cd barerepo &&
 796                 git maintenance register &&
 797                 git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 798                 git maintenance unregister &&
 799                 test_must_fail git config --global --get-all maintenance.repo
 800         )
 801 '
 802
 803 test_done