t/t7006-pager.sh

   1 #!/bin/sh
   2
   3 test_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
   9 test_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
  19 test_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
  25 test_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
  40 test_expect_success TTY 'LESS and LV envvars are set for pagination' '
  41         (
  42                 sane_unset LESS LV &&
  43                 PAGER="env >pager-env.out; wc" &&
  44                 export PAGER &&
  45
  46                 test_terminal git log
  47         ) &&
  48         grep ^LESS= pager-env.out &&
  49         grep ^LV= pager-env.out
  50 '
  51
  52 test_expect_success TTY 'some commands do not use a pager' '
  53         rm -f paginated.out &&
  54         test_terminal git rev-list HEAD &&
  55         ! test -e paginated.out
  56 '
  57
  58 test_expect_success 'no pager when stdout is a pipe' '
  59         rm -f paginated.out &&
  60         git log | cat &&
  61         ! test -e paginated.out
  62 '
  63
  64 test_expect_success 'no pager when stdout is a regular file' '
  65         rm -f paginated.out &&
  66         git log >file &&
  67         ! test -e paginated.out
  68 '
  69
  70 test_expect_success TTY 'git --paginate rev-list uses a pager' '
  71         rm -f paginated.out &&
  72         test_terminal git --paginate rev-list HEAD &&
  73         test -e paginated.out
  74 '
  75
  76 test_expect_success 'no pager even with --paginate when stdout is a pipe' '
  77         rm -f file paginated.out &&
  78         git --paginate log | cat &&
  79         ! test -e paginated.out
  80 '
  81
  82 test_expect_success TTY 'no pager with --no-pager' '
  83         rm -f paginated.out &&
  84         test_terminal git --no-pager log &&
  85         ! test -e paginated.out
  86 '
  87
  88 test_expect_success TTY 'configuration can disable pager' '
  89         rm -f paginated.out &&
  90         test_unconfig pager.grep &&
  91         test_terminal git grep initial &&
  92         test -e paginated.out &&
  93
  94         rm -f paginated.out &&
  95         test_config pager.grep false &&
  96         test_terminal git grep initial &&
  97         ! test -e paginated.out
  98 '
  99
 100 test_expect_success TTY 'git config uses a pager if configured to' '
 101         rm -f paginated.out &&
 102         test_config pager.config true &&
 103         test_terminal git config --list &&
 104         test -e paginated.out
 105 '
 106
 107 test_expect_success TTY 'configuration can enable pager (from subdir)' '
 108         rm -f paginated.out &&
 109         mkdir -p subdir &&
 110         test_config pager.bundle true &&
 111
 112         git bundle create test.bundle --all &&
 113         rm -f paginated.out subdir/paginated.out &&
 114         (
 115                 cd subdir &&
 116                 test_terminal git bundle unbundle ../test.bundle
 117         ) &&
 118         {
 119                 test -e paginated.out ||
 120                 test -e subdir/paginated.out
 121         }
 122 '
 123
 124 # A colored commit log will begin with an appropriate ANSI escape
 125 # for the first color; the text "commit" comes later.
 126 colorful() {
 127         read firstline <$1
 128         ! expr "$firstline" : "[a-zA-Z]" >/dev/null
 129 }
 130
 131 test_expect_success 'tests can detect color' '
 132         rm -f colorful.log colorless.log &&
 133         git log --no-color >colorless.log &&
 134         git log --color >colorful.log &&
 135         ! colorful colorless.log &&
 136         colorful colorful.log
 137 '
 138
 139 test_expect_success 'no color when stdout is a regular file' '
 140         rm -f colorless.log &&
 141         test_config color.ui auto &&
 142         git log >colorless.log &&
 143         ! colorful colorless.log
 144 '
 145
 146 test_expect_success TTY 'color when writing to a pager' '
 147         rm -f paginated.out &&
 148         test_config color.ui auto &&
 149         test_terminal env TERM=vt100 git log &&
 150         colorful paginated.out
 151 '
 152
 153 test_expect_success TTY 'colors are suppressed by color.pager' '
 154         rm -f paginated.out &&
 155         test_config color.ui auto &&
 156         test_config color.pager false &&
 157         test_terminal env TERM=vt100 git log &&
 158         ! colorful paginated.out
 159 '
 160
 161 test_expect_success 'color when writing to a file intended for a pager' '
 162         rm -f colorful.log &&
 163         test_config color.ui auto &&
 164         (
 165                 TERM=vt100 &&
 166                 GIT_PAGER_IN_USE=true &&
 167                 export TERM GIT_PAGER_IN_USE &&
 168                 git log >colorful.log
 169         ) &&
 170         colorful colorful.log
 171 '
 172
 173 test_expect_success TTY 'colors are sent to pager for external commands' '
 174         test_config alias.externallog "!git log" &&
 175         test_config color.ui auto &&
 176         test_terminal env TERM=vt100 git -p externallog &&
 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 #
 198 parse_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
 212 test_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
 233 test_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
 247 test_core_pager_overrides() {
 248         if_local_config=
 249         used_if_wanted='overrides PAGER'
 250         test_core_pager "$@"
 251 }
 252
 253 test_local_config_ignored() {
 254         if_local_config='! '
 255         used_if_wanted='is not used'
 256         test_core_pager "$@"
 257 }
 258
 259 test_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
 273 test_core_pager_subdir() {
 274         if_local_config=
 275         used_if_wanted='overrides PAGER'
 276         test_pager_subdir_helper "$@"
 277 }
 278
 279 test_no_local_config_subdir() {
 280         if_local_config='! '
 281         used_if_wanted='is not used'
 282         test_pager_subdir_helper "$@"
 283 }
 284
 285 test_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
 305 test_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
 318 test_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
 330 test_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
 338 test_expect_success 'setup: some aliases' '
 339         git config alias.aliasedlog log &&
 340         git config alias.true "!true"
 341 '
 342
 343 test_pager_choices                       'git log'
 344 test_pager_choices                       'git -p log'
 345 test_pager_choices                       'git aliasedlog'
 346
 347 test_default_pager        expect_success 'git -p aliasedlog'
 348 test_PAGER_overrides      expect_success 'git -p aliasedlog'
 349 test_core_pager_overrides expect_success 'git -p aliasedlog'
 350 test_core_pager_subdir    expect_failure 'git -p aliasedlog'
 351 test_GIT_PAGER_overrides  expect_success 'git -p aliasedlog'
 352
 353 test_default_pager        expect_success 'git -p true'
 354 test_PAGER_overrides      expect_success 'git -p true'
 355 test_core_pager_overrides expect_success 'git -p true'
 356 test_core_pager_subdir    expect_failure 'git -p true'
 357 test_GIT_PAGER_overrides  expect_success 'git -p true'
 358
 359 test_default_pager        expect_success test_must_fail 'git -p request-pull'
 360 test_PAGER_overrides      expect_success test_must_fail 'git -p request-pull'
 361 test_core_pager_overrides expect_success test_must_fail 'git -p request-pull'
 362 test_core_pager_subdir    expect_failure test_must_fail 'git -p request-pull'
 363 test_GIT_PAGER_overrides  expect_success test_must_fail 'git -p request-pull'
 364
 365 test_default_pager        expect_success test_must_fail 'git -p'
 366 test_PAGER_overrides      expect_success test_must_fail 'git -p'
 367 test_local_config_ignored expect_failure test_must_fail 'git -p'
 368 test_no_local_config_subdir expect_success test_must_fail 'git -p'
 369 test_GIT_PAGER_overrides  expect_success test_must_fail 'git -p'
 370
 371 test_doesnt_paginate      expect_failure test_must_fail 'git -p nonsense'
 372
 373 test_pager_choices                       'git shortlog'
 374 test_expect_success 'setup: configure shortlog not to paginate' '
 375         git config pager.shortlog false
 376 '
 377 test_doesnt_paginate      expect_success 'git shortlog'
 378 test_no_local_config_subdir expect_success 'git shortlog'
 379 test_default_pager        expect_success 'git -p shortlog'
 380 test_core_pager_subdir    expect_success 'git -p shortlog'
 381
 382 test_core_pager_subdir    expect_success test_must_fail \
 383                                          'git -p apply </dev/null'
 384
 385 test_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
 395 test_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
 405 test_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
 414 test_expect_success 'setup external command' '
 415         cat >git-external <<-\EOF &&
 416         #!/bin/sh
 417         git "$@"
 418         EOF
 419         chmod +x git-external
 420 '
 421
 422 test_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
 431 test_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
 440 test_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
 450 test_done