t/t7006-pager.sh

   1 #!/bin/sh
   2
   3 test_description='Test automatic use of a pager.'
   4
   5 . ./test-lib.sh
   6
   7 cleanup_fail() {
   8         echo >&2 cleanup failed
   9         (exit 1)
  10 }
  11
  12 test_expect_success 'set up terminal for tests' '
  13         rm -f stdout_is_tty ||
  14         cleanup_fail &&
  15
  16         if test -t 1
  17         then
  18                 >stdout_is_tty
  19         elif
  20                 test_have_prereq PERL &&
  21                 "$PERL_PATH" "$TEST_DIRECTORY"/t7006/test-terminal.perl \
  22                         sh -c "test -t 1"
  23         then
  24                 >test_terminal_works
  25         fi
  26 '
  27
  28 if test -e stdout_is_tty
  29 then
  30         test_terminal() { "$@"; }
  31         test_set_prereq TTY
  32 elif test -e test_terminal_works
  33 then
  34         test_terminal() {
  35                 "$PERL_PATH" "$TEST_DIRECTORY"/t7006/test-terminal.perl "$@"
  36         }
  37         test_set_prereq TTY
  38 else
  39         say no usable terminal, so skipping some tests
  40 fi
  41
  42 test_expect_success 'setup' '
  43         unset GIT_PAGER GIT_PAGER_IN_USE;
  44         test_might_fail git config --unset core.pager &&
  45
  46         PAGER="cat >paginated.out" &&
  47         export PAGER &&
  48
  49         test_commit initial
  50 '
  51
  52 test_expect_success TTY 'some commands use a pager' '
  53         rm -f paginated.out ||
  54         cleanup_fail &&
  55
  56         test_terminal git log &&
  57         test -e paginated.out
  58 '
  59
  60 test_expect_success TTY 'some commands do not use a pager' '
  61         rm -f paginated.out ||
  62         cleanup_fail &&
  63
  64         test_terminal git rev-list HEAD &&
  65         ! test -e paginated.out
  66 '
  67
  68 test_expect_success 'no pager when stdout is a pipe' '
  69         rm -f paginated.out ||
  70         cleanup_fail &&
  71
  72         git log | cat &&
  73         ! test -e paginated.out
  74 '
  75
  76 test_expect_success 'no pager when stdout is a regular file' '
  77         rm -f paginated.out ||
  78         cleanup_fail &&
  79
  80         git log >file &&
  81         ! test -e paginated.out
  82 '
  83
  84 test_expect_success TTY 'git --paginate rev-list uses a pager' '
  85         rm -f paginated.out ||
  86         cleanup_fail &&
  87
  88         test_terminal git --paginate rev-list HEAD &&
  89         test -e paginated.out
  90 '
  91
  92 test_expect_success 'no pager even with --paginate when stdout is a pipe' '
  93         rm -f file paginated.out ||
  94         cleanup_fail &&
  95
  96         git --paginate log | cat &&
  97         ! test -e paginated.out
  98 '
  99
 100 test_expect_success TTY 'no pager with --no-pager' '
 101         rm -f paginated.out ||
 102         cleanup_fail &&
 103
 104         test_terminal git --no-pager log &&
 105         ! test -e paginated.out
 106 '
 107
 108 # A colored commit log will begin with an appropriate ANSI escape
 109 # for the first color; the text "commit" comes later.
 110 colorful() {
 111         read firstline <$1
 112         ! expr "$firstline" : "[a-zA-Z]" >/dev/null
 113 }
 114
 115 test_expect_success 'tests can detect color' '
 116         rm -f colorful.log colorless.log ||
 117         cleanup_fail &&
 118
 119         git log --no-color >colorless.log &&
 120         git log --color >colorful.log &&
 121         ! colorful colorless.log &&
 122         colorful colorful.log
 123 '
 124
 125 test_expect_success 'no color when stdout is a regular file' '
 126         rm -f colorless.log &&
 127         git config color.ui auto ||
 128         cleanup_fail &&
 129
 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         git config color.ui auto ||
 137         cleanup_fail &&
 138
 139         (
 140                 TERM=vt100 &&
 141                 export TERM &&
 142                 test_terminal git log
 143         ) &&
 144         colorful paginated.out
 145 '
 146
 147 test_expect_success 'color when writing to a file intended for a pager' '
 148         rm -f colorful.log &&
 149         git config color.ui auto ||
 150         cleanup_fail &&
 151
 152         (
 153                 TERM=vt100 &&
 154                 GIT_PAGER_IN_USE=true &&
 155                 export TERM GIT_PAGER_IN_USE &&
 156                 git log >colorful.log
 157         ) &&
 158         colorful colorful.log
 159 '
 160
 161 test_expect_success 'determine default pager' '
 162         unset PAGER GIT_PAGER;
 163         test_might_fail git config --unset core.pager ||
 164         cleanup_fail &&
 165
 166         less=$(git var GIT_PAGER) &&
 167         test -n "$less"
 168 '
 169
 170 if expr "$less" : '[a-z][a-z]*$' >/dev/null && test_have_prereq TTY
 171 then
 172         test_set_prereq SIMPLEPAGER
 173 fi
 174
 175 # Use this helper to make it easy for the caller of your
 176 # terminal-using function to specify whether it should fail.
 177 # If you write
 178 #
 179 #       your_test() {
 180 #               parse_args "$@"
 181 #
 182 #               $test_expectation "$cmd - behaves well" "
 183 #                       ...
 184 #                       $full_command &&
 185 #                       ...
 186 #               "
 187 #       }
 188 #
 189 # then your test can be used like this:
 190 #
 191 #       your_test expect_(success|failure) [test_must_fail] 'git foo'
 192 #
 193 parse_args() {
 194         test_expectation="test_$1"
 195         shift
 196         if test "$1" = test_must_fail
 197         then
 198                 full_command="test_must_fail test_terminal "
 199                 shift
 200         else
 201                 full_command="test_terminal "
 202         fi
 203         cmd=$1
 204         full_command="$full_command $1"
 205 }
 206
 207 parse_args expect_success 'git log'
 208 $test_expectation SIMPLEPAGER "$cmd - default pager is used by default" "
 209         unset PAGER GIT_PAGER;
 210         test_might_fail git config --unset core.pager &&
 211         rm -f default_pager_used ||
 212         cleanup_fail &&
 213
 214         cat >\$less <<-\EOF &&
 215         #!/bin/sh
 216         wc >default_pager_used
 217         EOF
 218         chmod +x \$less &&
 219         (
 220                 PATH=.:\$PATH &&
 221                 export PATH &&
 222                 $full_command
 223         ) &&
 224         test -e default_pager_used
 225 "
 226
 227 parse_args expect_success 'git log'
 228 $test_expectation TTY "$cmd - PAGER overrides default pager" "
 229         unset GIT_PAGER;
 230         test_might_fail git config --unset core.pager &&
 231         rm -f PAGER_used ||
 232         cleanup_fail &&
 233
 234         PAGER='wc >PAGER_used' &&
 235         export PAGER &&
 236         $full_command &&
 237         test -e PAGER_used
 238 "
 239
 240 parse_args expect_success 'git log'
 241 $test_expectation TTY "$cmd - core.pager overrides PAGER" "
 242         unset GIT_PAGER;
 243         rm -f core.pager_used ||
 244         cleanup_fail &&
 245
 246         PAGER=wc &&
 247         export PAGER &&
 248         git config core.pager 'wc >core.pager_used' &&
 249         $full_command &&
 250         test -e core.pager_used
 251 "
 252
 253 parse_args expect_success 'git log'
 254 $test_expectation TTY "$cmd - GIT_PAGER overrides core.pager" "
 255         rm -f GIT_PAGER_used ||
 256         cleanup_fail &&
 257
 258         git config core.pager wc &&
 259         GIT_PAGER='wc >GIT_PAGER_used' &&
 260         export GIT_PAGER &&
 261         $full_command &&
 262         test -e GIT_PAGER_used
 263 "
 264
 265 test_done