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 '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
  46 test_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
  52 test_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
  58 test_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
  64 test_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
  70 test_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
  76 test_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
  88 test_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
  95 test_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.
 114 colorful() {
 115         read firstline <$1
 116         ! expr "$firstline" : "[a-zA-Z]" >/dev/null
 117 }
 118
 119 test_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
 127 test_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
 134 test_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
 145 test_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
 157 test_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
 169 test_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 #
 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