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         git config --global --add maintenance.repo /existing1 &&
 484         git config --global --add maintenance.repo /existing2 &&
 485         git config --global --get-all maintenance.repo >before &&
 486
 487         git maintenance register &&
 488         test_cmp_config false maintenance.auto &&
 489         git config --global --get-all maintenance.repo >between &&
 490         cp before expect &&
 491         pwd >>expect &&
 492         test_cmp expect between &&
 493
 494         git maintenance unregister &&
 495         git config --global --get-all maintenance.repo >actual &&
 496         test_cmp before actual
 497 '
 498
 499 test_expect_success !MINGW 'register and unregister with regex metacharacters' '
 500         META="a+b*c" &&
 501         git init "$META" &&
 502         git -C "$META" maintenance register &&
 503         git config --get-all --show-origin maintenance.repo &&
 504         git config --get-all --global --fixed-value \
 505                 maintenance.repo "$(pwd)/$META" &&
 506         git -C "$META" maintenance unregister &&
 507         test_must_fail git config --get-all --global --fixed-value \
 508                 maintenance.repo "$(pwd)/$META"
 509 '
 510
 511 test_expect_success 'start --scheduler=<scheduler>' '
 512         test_expect_code 129 git maintenance start --scheduler=foo 2>err &&
 513         test_i18ngrep "unrecognized --scheduler argument" err &&
 514
 515         test_expect_code 129 git maintenance start --no-scheduler 2>err &&
 516         test_i18ngrep "unknown option" err &&
 517
 518         test_expect_code 128 \
 519                 env GIT_TEST_MAINT_SCHEDULER="launchctl:true,schtasks:true" \
 520                 git maintenance start --scheduler=crontab 2>err &&
 521         test_i18ngrep "fatal: crontab scheduler is not available" err
 522 '
 523
 524 test_expect_success 'start from empty cron table' '
 525         GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab cron.txt" git maintenance start --scheduler=crontab &&
 526
 527         # start registers the repo
 528         git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 529
 530         grep "for-each-repo --config=maintenance.repo maintenance run --schedule=daily" cron.txt &&
 531         grep "for-each-repo --config=maintenance.repo maintenance run --schedule=hourly" cron.txt &&
 532         grep "for-each-repo --config=maintenance.repo maintenance run --schedule=weekly" cron.txt
 533 '
 534
 535 test_expect_success 'stop from existing schedule' '
 536         GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab cron.txt" git maintenance stop &&
 537
 538         # stop does not unregister the repo
 539         git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 540
 541         # Operation is idempotent
 542         GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab cron.txt" git maintenance stop &&
 543         test_must_be_empty cron.txt
 544 '
 545
 546 test_expect_success 'start preserves existing schedule' '
 547         echo "Important information!" >cron.txt &&
 548         GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab cron.txt" git maintenance start --scheduler=crontab &&
 549         grep "Important information!" cron.txt
 550 '
 551
 552 test_expect_success 'magic markers are correct' '
 553         grep "GIT MAINTENANCE SCHEDULE" cron.txt >actual &&
 554         cat >expect <<-\EOF &&
 555         # BEGIN GIT MAINTENANCE SCHEDULE
 556         # END GIT MAINTENANCE SCHEDULE
 557         EOF
 558         test_cmp actual expect
 559 '
 560
 561 test_expect_success 'stop preserves surrounding schedule' '
 562         echo "Crucial information!" >>cron.txt &&
 563         GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab cron.txt" git maintenance stop &&
 564         grep "Important information!" cron.txt &&
 565         grep "Crucial information!" cron.txt
 566 '
 567
 568 test_expect_success 'start and stop macOS maintenance' '
 569         # ensure $HOME can be compared against hook arguments on all platforms
 570         pfx=$(cd "$HOME" && pwd) &&
 571
 572         write_script print-args <<-\EOF &&
 573         echo $* | sed "s:gui/[0-9][0-9]*:gui/[UID]:" >>args
 574         EOF
 575
 576         rm -f args &&
 577         GIT_TEST_MAINT_SCHEDULER=launchctl:./print-args git maintenance start --scheduler=launchctl &&
 578
 579         # start registers the repo
 580         git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 581
 582         ls "$HOME/Library/LaunchAgents" >actual &&
 583         cat >expect <<-\EOF &&
 584         org.git-scm.git.daily.plist
 585         org.git-scm.git.hourly.plist
 586         org.git-scm.git.weekly.plist
 587         EOF
 588         test_cmp expect actual &&
 589
 590         rm -f expect &&
 591         for frequency in hourly daily weekly
 592         do
 593                 PLIST="$pfx/Library/LaunchAgents/org.git-scm.git.$frequency.plist" &&
 594                 test_xmllint "$PLIST" &&
 595                 grep schedule=$frequency "$PLIST" &&
 596                 echo "bootout gui/[UID] $PLIST" >>expect &&
 597                 echo "bootstrap gui/[UID] $PLIST" >>expect || return 1
 598         done &&
 599         test_cmp expect args &&
 600
 601         rm -f args &&
 602         GIT_TEST_MAINT_SCHEDULER=launchctl:./print-args git maintenance stop &&
 603
 604         # stop does not unregister the repo
 605         git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 606
 607         printf "bootout gui/[UID] $pfx/Library/LaunchAgents/org.git-scm.git.%s.plist\n" \
 608                 hourly daily weekly >expect &&
 609         test_cmp expect args &&
 610         ls "$HOME/Library/LaunchAgents" >actual &&
 611         test_line_count = 0 actual
 612 '
 613
 614 test_expect_success 'use launchctl list to prevent extra work' '
 615         # ensure we are registered
 616         GIT_TEST_MAINT_SCHEDULER=launchctl:./print-args git maintenance start --scheduler=launchctl &&
 617
 618         # do it again on a fresh args file
 619         rm -f args &&
 620         GIT_TEST_MAINT_SCHEDULER=launchctl:./print-args git maintenance start --scheduler=launchctl &&
 621
 622         ls "$HOME/Library/LaunchAgents" >actual &&
 623         cat >expect <<-\EOF &&
 624         list org.git-scm.git.hourly
 625         list org.git-scm.git.daily
 626         list org.git-scm.git.weekly
 627         EOF
 628         test_cmp expect args
 629 '
 630
 631 test_expect_success 'start and stop Windows maintenance' '
 632         write_script print-args <<-\EOF &&
 633         echo $* >>args
 634         while test $# -gt 0
 635         do
 636                 case "$1" in
 637                 /xml) shift; xmlfile=$1; break ;;
 638                 *) shift ;;
 639                 esac
 640         done
 641         test -z "$xmlfile" || cp "$xmlfile" "$xmlfile.xml"
 642         EOF
 643
 644         rm -f args &&
 645         GIT_TEST_MAINT_SCHEDULER="schtasks:./print-args" git maintenance start --scheduler=schtasks &&
 646
 647         # start registers the repo
 648         git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 649
 650         for frequency in hourly daily weekly
 651         do
 652                 grep "/create /tn Git Maintenance ($frequency) /f /xml" args &&
 653                 file=$(ls .git/schedule_${frequency}*.xml) &&
 654                 test_xmllint "$file" || return 1
 655         done &&
 656
 657         rm -f args &&
 658         GIT_TEST_MAINT_SCHEDULER="schtasks:./print-args" git maintenance stop &&
 659
 660         # stop does not unregister the repo
 661         git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 662
 663         printf "/delete /tn Git Maintenance (%s) /f\n" \
 664                 hourly daily weekly >expect &&
 665         test_cmp expect args
 666 '
 667
 668 test_expect_success 'start and stop Linux/systemd maintenance' '
 669         write_script print-args <<-\EOF &&
 670         printf "%s\n" "$*" >>args
 671         EOF
 672
 673         XDG_CONFIG_HOME="$PWD" &&
 674         export XDG_CONFIG_HOME &&
 675         rm -f args &&
 676         GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args" git maintenance start --scheduler=systemd-timer &&
 677
 678         # start registers the repo
 679         git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 680
 681         test_systemd_analyze_verify "systemd/user/git-maintenance@.service" &&
 682
 683         printf -- "--user enable --now git-maintenance@%s.timer\n" hourly daily weekly >expect &&
 684         test_cmp expect args &&
 685
 686         rm -f args &&
 687         GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args" git maintenance stop &&
 688
 689         # stop does not unregister the repo
 690         git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 691
 692         test_path_is_missing "systemd/user/git-maintenance@.timer" &&
 693         test_path_is_missing "systemd/user/git-maintenance@.service" &&
 694
 695         printf -- "--user disable --now git-maintenance@%s.timer\n" hourly daily weekly >expect &&
 696         test_cmp expect args
 697 '
 698
 699 test_expect_success 'start and stop when several schedulers are available' '
 700         write_script print-args <<-\EOF &&
 701         printf "%s\n" "$*" | sed "s:gui/[0-9][0-9]*:gui/[UID]:; s:\(schtasks /create .* /xml\).*:\1:;" >>args
 702         EOF
 703
 704         rm -f args &&
 705         GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args systemctl,launchctl:./print-args launchctl,schtasks:./print-args schtasks" git maintenance start --scheduler=systemd-timer &&
 706         printf "launchctl bootout gui/[UID] $pfx/Library/LaunchAgents/org.git-scm.git.%s.plist\n" \
 707                 hourly daily weekly >expect &&
 708         printf "schtasks /delete /tn Git Maintenance (%s) /f\n" \
 709                 hourly daily weekly >>expect &&
 710         printf -- "systemctl --user enable --now git-maintenance@%s.timer\n" hourly daily weekly >>expect &&
 711         test_cmp expect args &&
 712
 713         rm -f args &&
 714         GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args systemctl,launchctl:./print-args launchctl,schtasks:./print-args schtasks" git maintenance start --scheduler=launchctl &&
 715         printf -- "systemctl --user disable --now git-maintenance@%s.timer\n" hourly daily weekly >expect &&
 716         printf "schtasks /delete /tn Git Maintenance (%s) /f\n" \
 717                 hourly daily weekly >>expect &&
 718         for frequency in hourly daily weekly
 719         do
 720                 PLIST="$pfx/Library/LaunchAgents/org.git-scm.git.$frequency.plist" &&
 721                 echo "launchctl bootout gui/[UID] $PLIST" >>expect &&
 722                 echo "launchctl bootstrap gui/[UID] $PLIST" >>expect || return 1
 723         done &&
 724         test_cmp expect args &&
 725
 726         rm -f args &&
 727         GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args systemctl,launchctl:./print-args launchctl,schtasks:./print-args schtasks" git maintenance start --scheduler=schtasks &&
 728         printf -- "systemctl --user disable --now git-maintenance@%s.timer\n" hourly daily weekly >expect &&
 729         printf "launchctl bootout gui/[UID] $pfx/Library/LaunchAgents/org.git-scm.git.%s.plist\n" \
 730                 hourly daily weekly >>expect &&
 731         printf "schtasks /create /tn Git Maintenance (%s) /f /xml\n" \
 732                 hourly daily weekly >>expect &&
 733         test_cmp expect args &&
 734
 735         rm -f args &&
 736         GIT_TEST_MAINT_SCHEDULER="systemctl:./print-args systemctl,launchctl:./print-args launchctl,schtasks:./print-args schtasks" git maintenance stop &&
 737         printf -- "systemctl --user disable --now git-maintenance@%s.timer\n" hourly daily weekly >expect &&
 738         printf "launchctl bootout gui/[UID] $pfx/Library/LaunchAgents/org.git-scm.git.%s.plist\n" \
 739                 hourly daily weekly >>expect &&
 740         printf "schtasks /delete /tn Git Maintenance (%s) /f\n" \
 741                 hourly daily weekly >>expect &&
 742         test_cmp expect args
 743 '
 744
 745 test_expect_success 'register preserves existing strategy' '
 746         git config maintenance.strategy none &&
 747         git maintenance register &&
 748         test_config maintenance.strategy none &&
 749         git config --unset maintenance.strategy &&
 750         git maintenance register &&
 751         test_config maintenance.strategy incremental
 752 '
 753
 754 test_expect_success 'fails when running outside of a repository' '
 755         nongit test_must_fail git maintenance run &&
 756         nongit test_must_fail git maintenance stop &&
 757         nongit test_must_fail git maintenance start &&
 758         nongit test_must_fail git maintenance register &&
 759         nongit test_must_fail git maintenance unregister
 760 '
 761
 762 test_expect_success 'register and unregister bare repo' '
 763         test_when_finished "git config --global --unset-all maintenance.repo || :" &&
 764         test_might_fail git config --global --unset-all maintenance.repo &&
 765         git init --bare barerepo &&
 766         (
 767                 cd barerepo &&
 768                 git maintenance register &&
 769                 git config --get --global --fixed-value maintenance.repo "$(pwd)" &&
 770                 git maintenance unregister &&
 771                 test_must_fail git config --global --get-all maintenance.repo
 772         )
 773 '
 774
 775 test_done