t/test-lib.sh

   1 #!/bin/sh
   2 # Copyright (c) 2009 Rainbows! developers
   3 . ./my-tap-lib.sh
   4
   5 set +u
   6
   7 # sometimes we rely on http_proxy to avoid wasting bandwidth with Isolate
   8 # and multiple Ruby versions
   9 NO_PROXY=${UNICORN_TEST_ADDR-127.0.0.1}
  10 export NO_PROXY
  11
  12 if test -z "$model"
  13 then
  14         # defaulting to Base would unfortunately fail some concurrency tests
  15         model=ThreadSpawn
  16         t_info "model undefined, defaulting to $model"
  17 fi
  18
  19 set -e
  20 RUBY="${RUBY-ruby}"
  21 RUBY_VERSION=${RUBY_VERSION-$($RUBY -e 'puts RUBY_VERSION')}
  22 t_pfx=$PWD/trash/$model.$T-$RUBY_ENGINE-$RUBY_VERSION
  23 set -u
  24
  25 PATH=$PWD/bin:$PATH
  26 export PATH
  27
  28 test -x $PWD/bin/unused_listen || die "must be run in 't' directory"
  29
  30 # requires $1 and prints out the value of $2
  31 require_check () {
  32         lib=$1
  33         const=$2
  34         if ! $RUBY -r$lib -e "puts $const" >/dev/null 2>&1
  35         then
  36                 t_info "skipping $T since we don't have $lib"
  37                 exit 0
  38         fi
  39 }
  40
  41 skip_models () {
  42         for i in "$@"
  43         do
  44                 if test x"$model" != x"$i"
  45                 then
  46                         continue
  47                 fi
  48                 t_info "skipping $T since it is not compatible with $model"
  49                 exit 0
  50         done
  51 }
  52
  53
  54 # given a list of variable names, create temporary files and assign
  55 # the pathnames to those variables
  56 rtmpfiles () {
  57         for id in "$@"
  58         do
  59                 name=$id
  60                 _tmp=$t_pfx.$id
  61                 eval "$id=$_tmp"
  62
  63                 case $name in
  64                 *fifo)
  65                         rm -f $_tmp
  66                         mkfifo $_tmp
  67                         T_RM_LIST="$T_RM_LIST $_tmp"
  68                         ;;
  69                 *socket)
  70                         rm -f $_tmp
  71                         T_RM_LIST="$T_RM_LIST $_tmp"
  72                         ;;
  73                 *)
  74                         > $_tmp
  75                         T_OK_RM_LIST="$T_OK_RM_LIST $_tmp"
  76                         ;;
  77                 esac
  78         done
  79 }
  80
  81 dbgcat () {
  82         id=$1
  83         eval '_file=$'$id
  84         echo "==> $id <=="
  85         sed -e "s/^/$id:/" < $_file
  86 }
  87
  88 check_stderr () {
  89         set +u
  90         _r_err=${1-${r_err}}
  91         set -u
  92         if grep -i Error $_r_err
  93         then
  94                 die "Errors found in $_r_err"
  95         elif grep SIGKILL $_r_err
  96         then
  97                 die "SIGKILL found in $_r_err"
  98         fi
  99 }
 100
 101 # zbatery_setup [ MODEL [ WORKER_CONNECTIONS ] ]
 102 zbatery_setup () {
 103         eval $(unused_listen)
 104         rtmpfiles unicorn_config pid r_err r_out fifo tmp ok
 105         cat > $unicorn_config <<EOF
 106 listen "$listen"
 107 pid "$pid"
 108 stderr_path "$r_err"
 109 stdout_path "$r_out"
 110
 111 after_fork do |server, worker|
 112   # test script will block while reading from $fifo,
 113   # so notify the script on the first worker we spawn
 114   # by opening the FIFO
 115   if worker.nr == 0
 116     File.open("$fifo", "wb") { |fp| fp.syswrite "START" }
 117   end
 118 end
 119 EOF
 120         {
 121                 # set a higher default for tests since we run heavily-loaded
 122                 # boxes and sometimes sleep 1s in tests
 123                 kato=5
 124                 echo 'Rainbows! do'
 125                 echo "  client_max_body_size nil"
 126                 if test $# -ge 1
 127                 then
 128                         echo "  use :$1"
 129                         test $# -ge 2 && echo "  worker_connections $2"
 130                         if test $# -eq 3
 131                         then
 132                                 echo "  keepalive_timeout $3"
 133                         else
 134                                 echo "  keepalive_timeout $kato"
 135                         fi
 136                 else
 137                         echo "  use :$model"
 138                         echo "  keepalive_timeout $kato"
 139                 fi
 140                 echo end
 141         } >> $unicorn_config
 142 }
 143
 144 zbatery_wait_start () {
 145         # "cat $fifo" will block until the before_fork hook is called in
 146         # the Unicorn config file
 147         test xSTART = x"$(cat $fifo)"
 148         zbatery_pid=$(cat $pid)
 149 }
 150
 151 rsha1 () {
 152         _cmd="$(which sha1sum 2>/dev/null || :)"
 153         test -n "$_cmd" || _cmd="$(which openssl 2>/dev/null || :) sha1"
 154         test "$_cmd" != " sha1" || _cmd="$(which gsha1sum 2>/dev/null || :)"
 155
 156         # last resort, see comments in sha1sum.rb for reasoning
 157         test -n "$_cmd" || _cmd=sha1sum.rb
 158         expr "$($_cmd)" : '\([a-f0-9]\{40\}\)'
 159 }
 160
 161 req_curl_chunked_upload_err_check () {
 162         set +e
 163         curl --version 2>/dev/null | awk '$1 == "curl" {
 164                 split($2, v, /\./)
 165                 if ((v[1] < 7) || (v[1] == 7 && v[2] < 18))
 166                         code = 1
 167         }
 168         END { exit(code) }'
 169         if test $? -ne 0
 170         then
 171                 t_info "curl >= 7.18.0 required for $T"
 172                 exit 0
 173         fi
 174 }
 175
 176 case $model in
 177 Rev) require_check rev Rev::VERSION ;;
 178 Coolio) require_check coolio Coolio::VERSION ;;
 179 Revactor) require_check revactor Revactor::VERSION ;;
 180 EventMachine) require_check eventmachine EventMachine::VERSION ;;
 181 esac