Andrew's git - gitweb.git/blob

   1#!/bin/sh
   2
   3test_description='Test automatic use of a pager.'
   4
   5. ./test-lib.sh
   6. "$TEST_DIRECTORY"/lib-pager.sh
   7. "$TEST_DIRECTORY"/lib-terminal.sh
   8
   9test_expect_success 'setup' '
  10        sane_unset GIT_PAGER GIT_PAGER_IN_USE &&
  11        test_unconfig core.pager &&
  12
  13        PAGER="cat >paginated.out" &&
  14        export PAGER &&
  15
  16        test_commit initial
  17'
  18
  19test_expect_success TTY 'some commands use a pager' '
  20        rm -f paginated.out &&
  21        test_terminal git log &&
  22        test -e paginated.out
  23'
  24
  25test_expect_failure TTY 'pager runs from subdir' '
  26        echo subdir/paginated.out >expected &&
  27        mkdir -p subdir &&
  28        rm -f paginated.out subdir/paginated.out &&
  29        (
  30                cd subdir &&
  31                test_terminal git log
  32        ) &&
  33        {
  34                ls paginated.out subdir/paginated.out ||
  35                :
  36        } >actual &&
  37        test_cmp expected actual
  38'
  39
  40test_expect_success TTY 'some commands do not use a pager' '
  41        rm -f paginated.out &&
  42        test_terminal git rev-list HEAD &&
  43        ! test -e paginated.out
  44'
  45
  46test_expect_success 'no pager when stdout is a pipe' '
  47        rm -f paginated.out &&
  48        git log | cat &&
  49        ! test -e paginated.out
  50'
  51
  52test_expect_success 'no pager when stdout is a regular file' '
  53        rm -f paginated.out &&
  54        git log >file &&
  55        ! test -e paginated.out
  56'
  57
  58test_expect_success TTY 'git --paginate rev-list uses a pager' '
  59        rm -f paginated.out &&
  60        test_terminal git --paginate rev-list HEAD &&
  61        test -e paginated.out
  62'
  63
  64test_expect_success 'no pager even with --paginate when stdout is a pipe' '
  65        rm -f file paginated.out &&
  66        git --paginate log | cat &&
  67        ! test -e paginated.out
  68'
  69
  70test_expect_success TTY 'no pager with --no-pager' '
  71        rm -f paginated.out &&
  72        test_terminal git --no-pager log &&
  73        ! test -e paginated.out
  74'
  75
  76test_expect_success TTY 'configuration can disable pager' '
  77        rm -f paginated.out &&
  78        test_unconfig pager.grep &&
  79        test_terminal git grep initial &&
  80        test -e paginated.out &&
  81
  82        rm -f paginated.out &&
  83        test_config pager.grep false &&
  84        test_terminal git grep initial &&
  85        ! test -e paginated.out
  86'
  87
  88test_expect_success TTY 'git config uses a pager if configured to' '
  89        rm -f paginated.out &&
  90        test_config pager.config true &&
  91        test_terminal git config --list &&
  92        test -e paginated.out
  93'
  94
  95test_expect_success TTY 'configuration can enable pager (from subdir)' '
  96        rm -f paginated.out &&
  97        mkdir -p subdir &&
  98        test_config pager.bundle true &&
  99
 100        git bundle create test.bundle --all &&
 101        rm -f paginated.out subdir/paginated.out &&
 102        (
 103                cd subdir &&
 104                test_terminal git bundle unbundle ../test.bundle
 105        ) &&
 106        {
 107                test -e paginated.out ||
 108                test -e subdir/paginated.out
 109        }
 110'
 111
 112# A colored commit log will begin with an appropriate ANSI escape
 113# for the first color; the text "commit" comes later.
 114colorful() {
 115        read firstline <$1
 116        ! expr "$firstline" : "[a-zA-Z]" >/dev/null
 117}
 118
 119test_expect_success 'tests can detect color' '
 120        rm -f colorful.log colorless.log &&
 121        git log --no-color >colorless.log &&
 122        git log --color >colorful.log &&
 123        ! colorful colorless.log &&
 124        colorful colorful.log
 125'
 126
 127test_expect_success 'no color when stdout is a regular file' '
 128        rm -f colorless.log &&
 129        test_config color.ui auto &&
 130        git log >colorless.log &&
 131        ! colorful colorless.log
 132'
 133
 134test_expect_success TTY 'color when writing to a pager' '
 135        rm -f paginated.out &&
 136        test_config color.ui auto &&
 137        (
 138                TERM=vt100 &&
 139                export TERM &&
 140                test_terminal git log
 141        ) &&
 142        colorful paginated.out
 143'
 144
 145test_expect_success TTY 'colors are suppressed by color.pager' '
 146        rm -f paginated.out &&
 147        test_config color.ui auto &&
 148        test_config color.pager false &&
 149        (
 150                TERM=vt100 &&
 151                export TERM &&
 152                test_terminal git log
 153        ) &&
 154        ! colorful paginated.out
 155'
 156
 157test_expect_success 'color when writing to a file intended for a pager' '
 158        rm -f colorful.log &&
 159        test_config color.ui auto &&
 160        (
 161                TERM=vt100 &&
 162                GIT_PAGER_IN_USE=true &&
 163                export TERM GIT_PAGER_IN_USE &&
 164                git log >colorful.log
 165        ) &&
 166        colorful colorful.log
 167'
 168
 169test_expect_success TTY 'colors are sent to pager for external commands' '
 170        test_config alias.externallog "!git log" &&
 171        test_config color.ui auto &&
 172        (
 173                TERM=vt100 &&
 174                export TERM &&
 175                test_terminal git -p externallog
 176        ) &&
 177        colorful paginated.out
 178'
 179
 180# Use this helper to make it easy for the caller of your
 181# terminal-using function to specify whether it should fail.
 182# If you write
 183#
 184#       your_test() {
 185#               parse_args "$@"
 186#
 187#               $test_expectation "$cmd - behaves well" "
 188#                       ...
 189#                       $full_command &&
 190#                       ...
 191#               "
 192#       }
 193#
 194# then your test can be used like this:
 195#
 196#       your_test expect_(success|failure) [test_must_fail] 'git foo'
 197#
 198parse_args() {
 199        test_expectation="test_$1"
 200        shift
 201        if test "$1" = test_must_fail
 202        then
 203                full_command="test_must_fail test_terminal "
 204                shift
 205        else
 206                full_command="test_terminal "
 207        fi
 208        cmd=$1
 209        full_command="$full_command $1"
 210}
 211
 212test_default_pager() {
 213        parse_args "$@"
 214
 215        $test_expectation SIMPLEPAGER,TTY "$cmd - default pager is used by default" "
 216                sane_unset PAGER GIT_PAGER &&
 217                test_unconfig core.pager &&
 218                rm -f default_pager_used &&
 219                cat >\$less <<-\EOF &&
 220                #!/bin/sh
 221                wc >default_pager_used
 222                EOF
 223                chmod +x \$less &&
 224                (
 225                        PATH=.:\$PATH &&
 226                        export PATH &&
 227                        $full_command
 228                ) &&
 229                test -e default_pager_used
 230        "
 231}
 232
 233test_PAGER_overrides() {
 234        parse_args "$@"
 235
 236        $test_expectation TTY "$cmd - PAGER overrides default pager" "
 237                sane_unset GIT_PAGER &&
 238                test_unconfig core.pager &&
 239                rm -f PAGER_used &&
 240                PAGER='wc >PAGER_used' &&
 241                export PAGER &&
 242                $full_command &&
 243                test -e PAGER_used
 244        "
 245}
 246
 247test_core_pager_overrides() {
 248        if_local_config=
 249        used_if_wanted='overrides PAGER'
 250        test_core_pager "$@"
 251}
 252
 253test_local_config_ignored() {
 254        if_local_config='! '
 255        used_if_wanted='is not used'
 256        test_core_pager "$@"
 257}
 258
 259test_core_pager() {
 260        parse_args "$@"
 261
 262        $test_expectation TTY "$cmd - repository-local core.pager setting $used_if_wanted" "
 263                sane_unset GIT_PAGER &&
 264                rm -f core.pager_used &&
 265                PAGER=wc &&
 266                export PAGER &&
 267                test_config core.pager 'wc >core.pager_used' &&
 268                $full_command &&
 269                ${if_local_config}test -e core.pager_used
 270        "
 271}
 272
 273test_core_pager_subdir() {
 274        if_local_config=
 275        used_if_wanted='overrides PAGER'
 276        test_pager_subdir_helper "$@"
 277}
 278
 279test_no_local_config_subdir() {
 280        if_local_config='! '
 281        used_if_wanted='is not used'
 282        test_pager_subdir_helper "$@"
 283}
 284
 285test_pager_subdir_helper() {
 286        parse_args "$@"
 287
 288        $test_expectation TTY "$cmd - core.pager $used_if_wanted from subdirectory" "
 289                sane_unset GIT_PAGER &&
 290                rm -f core.pager_used &&
 291                rm -fr sub &&
 292                PAGER=wc &&
 293                stampname=\$(pwd)/core.pager_used &&
 294                export PAGER stampname &&
 295                test_config core.pager 'wc >\"\$stampname\"' &&
 296                mkdir sub &&
 297                (
 298                        cd sub &&
 299                        $full_command
 300                ) &&
 301                ${if_local_config}test -e core.pager_used
 302        "
 303}
 304
 305test_GIT_PAGER_overrides() {
 306        parse_args "$@"
 307
 308        $test_expectation TTY "$cmd - GIT_PAGER overrides core.pager" "
 309                rm -f GIT_PAGER_used &&
 310                test_config core.pager wc &&
 311                GIT_PAGER='wc >GIT_PAGER_used' &&
 312                export GIT_PAGER &&
 313                $full_command &&
 314                test -e GIT_PAGER_used
 315        "
 316}
 317
 318test_doesnt_paginate() {
 319        parse_args "$@"
 320
 321        $test_expectation TTY "no pager for '$cmd'" "
 322                rm -f GIT_PAGER_used &&
 323                GIT_PAGER='wc >GIT_PAGER_used' &&
 324                export GIT_PAGER &&
 325                $full_command &&
 326                ! test -e GIT_PAGER_used
 327        "
 328}
 329
 330test_pager_choices() {
 331        test_default_pager        expect_success "$@"
 332        test_PAGER_overrides      expect_success "$@"
 333        test_core_pager_overrides expect_success "$@"
 334        test_core_pager_subdir    expect_success "$@"
 335        test_GIT_PAGER_overrides  expect_success "$@"
 336}
 337
 338test_expect_success 'setup: some aliases' '
 339        git config alias.aliasedlog log &&
 340        git config alias.true "!true"
 341'
 342
 343test_pager_choices                       'git log'
 344test_pager_choices                       'git -p log'
 345test_pager_choices                       'git aliasedlog'
 346
 347test_default_pager        expect_success 'git -p aliasedlog'
 348test_PAGER_overrides      expect_success 'git -p aliasedlog'
 349test_core_pager_overrides expect_success 'git -p aliasedlog'
 350test_core_pager_subdir    expect_failure 'git -p aliasedlog'
 351test_GIT_PAGER_overrides  expect_success 'git -p aliasedlog'
 352
 353test_default_pager        expect_success 'git -p true'
 354test_PAGER_overrides      expect_success 'git -p true'
 355test_core_pager_overrides expect_success 'git -p true'
 356test_core_pager_subdir    expect_failure 'git -p true'
 357test_GIT_PAGER_overrides  expect_success 'git -p true'
 358
 359test_default_pager        expect_success test_must_fail 'git -p request-pull'
 360test_PAGER_overrides      expect_success test_must_fail 'git -p request-pull'
 361test_core_pager_overrides expect_success test_must_fail 'git -p request-pull'
 362test_core_pager_subdir    expect_failure test_must_fail 'git -p request-pull'
 363test_GIT_PAGER_overrides  expect_success test_must_fail 'git -p request-pull'
 364
 365test_default_pager        expect_success test_must_fail 'git -p'
 366test_PAGER_overrides      expect_success test_must_fail 'git -p'
 367test_local_config_ignored expect_failure test_must_fail 'git -p'
 368test_no_local_config_subdir expect_success test_must_fail 'git -p'
 369test_GIT_PAGER_overrides  expect_success test_must_fail 'git -p'
 370
 371test_doesnt_paginate      expect_failure test_must_fail 'git -p nonsense'
 372
 373test_pager_choices                       'git shortlog'
 374test_expect_success 'setup: configure shortlog not to paginate' '
 375        git config pager.shortlog false
 376'
 377test_doesnt_paginate      expect_success 'git shortlog'
 378test_no_local_config_subdir expect_success 'git shortlog'
 379test_default_pager        expect_success 'git -p shortlog'
 380test_core_pager_subdir    expect_success 'git -p shortlog'
 381
 382test_core_pager_subdir    expect_success test_must_fail \
 383                                         'git -p apply </dev/null'
 384
 385test_expect_success TTY 'command-specific pager' '
 386        sane_unset PAGER GIT_PAGER &&
 387        echo "foo:initial" >expect &&
 388        >actual &&
 389        test_unconfig core.pager &&
 390        test_config pager.log "sed s/^/foo:/ >actual" &&
 391        test_terminal git log --format=%s -1 &&
 392        test_cmp expect actual
 393'
 394
 395test_expect_success TTY 'command-specific pager overrides core.pager' '
 396        sane_unset PAGER GIT_PAGER &&
 397        echo "foo:initial" >expect &&
 398        >actual &&
 399        test_config core.pager "exit 1"
 400        test_config pager.log "sed s/^/foo:/ >actual" &&
 401        test_terminal git log --format=%s -1 &&
 402        test_cmp expect actual
 403'
 404
 405test_expect_success TTY 'command-specific pager overridden by environment' '
 406        GIT_PAGER="sed s/^/foo:/ >actual" && export GIT_PAGER &&
 407        >actual &&
 408        echo "foo:initial" >expect &&
 409        test_config pager.log "exit 1" &&
 410        test_terminal git log --format=%s -1 &&
 411        test_cmp expect actual
 412'
 413
 414test_expect_success 'setup external command' '
 415        cat >git-external <<-\EOF &&
 416        #!/bin/sh
 417        git "$@"
 418        EOF
 419        chmod +x git-external
 420'
 421
 422test_expect_success TTY 'command-specific pager works for external commands' '
 423        sane_unset PAGER GIT_PAGER &&
 424        echo "foo:initial" >expect &&
 425        >actual &&
 426        test_config pager.external "sed s/^/foo:/ >actual" &&
 427        test_terminal git --exec-path="`pwd`" external log --format=%s -1 &&
 428        test_cmp expect actual
 429'
 430
 431test_expect_success TTY 'sub-commands of externals use their own pager' '
 432        sane_unset PAGER GIT_PAGER &&
 433        echo "foo:initial" >expect &&
 434        >actual &&
 435        test_config pager.log "sed s/^/foo:/ >actual" &&
 436        test_terminal git --exec-path=. external log --format=%s -1 &&
 437        test_cmp expect actual
 438'
 439
 440test_expect_success TTY 'external command pagers override sub-commands' '
 441        sane_unset PAGER GIT_PAGER &&
 442        >expect &&
 443        >actual &&
 444        test_config pager.external false &&
 445        test_config pager.log "sed s/^/log:/ >actual" &&
 446        test_terminal git --exec-path=. external log --format=%s -1 &&
 447        test_cmp expect actual
 448'
 449
 450test_done