t/t0104-rack-input-limit-tiny.sh

   1 #!/bin/sh
   2 . ./test-lib.sh
   3 skip_models StreamResponseEpoll
   4 test -r random_blob || die "random_blob required, run with 'make $0'"
   5 req_curl_chunked_upload_err_check
   6
   7 t_plan 18 "rack.input client_max_body_size tiny"
   8
   9 t_begin "setup and startup" && {
  10         rtmpfiles curl_out curl_err
  11         rainbows_setup $model
  12         ed -s $unicorn_config <<EOF
  13 ,s/client_max_body_size.*/client_max_body_size 256/
  14 w
  15 EOF
  16         rainbows -D sha1-random-size.ru -c $unicorn_config
  17         rainbows_wait_start
  18 }
  19
  20 t_begin "stops a regular request" && {
  21         rm -f $ok
  22         dd if=/dev/zero bs=257 count=1 of=$tmp
  23         curl -vsSf -T $tmp -H Expect: \
  24           http://$listen/ > $curl_out 2> $curl_err || > $ok
  25         dbgcat curl_err
  26         dbgcat curl_out
  27         grep 413 $curl_err
  28         test -e $ok
  29 }
  30
  31 t_begin "stops a large chunked request" && {
  32         rm -f $ok
  33         dd if=/dev/zero bs=257 count=1 | \
  34           curl -vsSf -T- -H Expect: \
  35           http://$listen/ > $curl_out 2> $curl_err || > $ok
  36         dbgcat curl_err
  37         dbgcat curl_out
  38         grep 413 $curl_err
  39         test -e $ok
  40 }
  41
  42 t_begin "small size sha1 chunked ok" && {
  43         blob_sha1=b376885ac8452b6cbf9ced81b1080bfd570d9b91
  44         rm -f $ok
  45         dd if=/dev/zero bs=256 count=1 | \
  46           curl -vsSf -T- -H Expect: \
  47           http://$listen/ > $curl_out 2> $curl_err
  48         dbgcat curl_err
  49         dbgcat curl_out
  50         test "$(cat $curl_out)" = $blob_sha1
  51 }
  52
  53 t_begin "small size sha1 content-length ok" && {
  54         blob_sha1=b376885ac8452b6cbf9ced81b1080bfd570d9b91
  55         rm -f $ok
  56         dd if=/dev/zero bs=256 count=1 of=$tmp
  57         curl -vsSf -T $tmp -H Expect: \
  58           http://$listen/ > $curl_out 2> $curl_err
  59         dbgcat curl_err
  60         dbgcat curl_out
  61         test "$(cat $curl_out)" = $blob_sha1
  62 }
  63
  64 t_begin "stops a regular request (gets_read_mix)" && {
  65         rm -f $ok
  66         dd if=/dev/zero bs=257 count=1 of=$tmp
  67         curl -vsSf -T $tmp -H Expect: \
  68           http://$listen/gets_read_mix > $curl_out 2> $curl_err || > $ok
  69         dbgcat curl_err
  70         dbgcat curl_out
  71         grep 413 $curl_err
  72         test -e $ok
  73 }
  74
  75 t_begin "stops a large chunked request (gets_read_mix)" && {
  76         rm -f $ok
  77         dd if=/dev/zero bs=257 count=1 | \
  78           curl -vsSf -T- -H Expect: \
  79           http://$listen/gets_read_mix > $curl_out 2> $curl_err || > $ok
  80         dbgcat curl_err
  81         dbgcat curl_out
  82         grep 413 $curl_err
  83         test -e $ok
  84 }
  85
  86 t_begin "stops a large line-based chunked request (gets_read_mix)" && {
  87         rm -f $ok
  88         </dev/null awk 'BEGIN{for(i=22;--i>=0;) print "hello world"}' | \
  89           curl -vsSf -T- -H Expect: \
  90           http://$listen/gets_read_mix > $curl_out 2> $curl_err || > $ok
  91         dbgcat curl_err
  92         dbgcat curl_out
  93         grep 413 $curl_err
  94         test -e $ok
  95 }
  96
  97 t_begin "OK with line-based chunked request (gets_read_mix)" && {
  98         rm -f $ok
  99         </dev/null awk 'BEGIN{for(i=21;--i>=0;) print "hello world"}' | \
 100           curl -vsSf -T- -H Expect: \
 101           http://$listen/gets_read_mix > $curl_out 2> $curl_err
 102         dbgcat curl_err
 103         dbgcat curl_out
 104         test x"$(cat $curl_out)" = x23eab3cebcbe22a0456c8462e3d3bb01ae761702
 105 }
 106
 107 t_begin "small size sha1 chunked ok (gets_read_mix)" && {
 108         blob_sha1=b376885ac8452b6cbf9ced81b1080bfd570d9b91
 109         rm -f $ok
 110         dd if=/dev/zero bs=256 count=1 | \
 111           curl -vsSf -T- -H Expect: \
 112           http://$listen/gets_read_mix > $curl_out 2> $curl_err
 113         dbgcat curl_err
 114         dbgcat curl_out
 115         test "$(cat $curl_out)" = $blob_sha1
 116 }
 117
 118 t_begin "small size sha1 content-length ok (gets_read_mix)" && {
 119         blob_sha1=b376885ac8452b6cbf9ced81b1080bfd570d9b91
 120         rm -f $ok
 121         dd if=/dev/zero bs=256 count=1 of=$tmp
 122         curl -vsSf -T $tmp -H Expect: \
 123           http://$listen/gets_read_mix > $curl_out 2> $curl_err
 124         dbgcat curl_err
 125         dbgcat curl_out
 126         test "$(cat $curl_out)" = $blob_sha1
 127 }
 128
 129 t_begin "stops a regular request (each)" && {
 130         rm -f $ok
 131         dd if=/dev/zero bs=257 count=1 of=$tmp
 132         curl -vsSf -T $tmp -H Expect: \
 133           http://$listen/each > $curl_out 2> $curl_err || > $ok
 134         dbgcat curl_err
 135         dbgcat curl_out
 136         grep 413 $curl_err
 137         test -e $ok
 138 }
 139
 140 t_begin "stops a large chunked request (each)" && {
 141         rm -f $ok
 142         dd if=/dev/zero bs=257 count=1 | \
 143           curl -vsSf -T- -H Expect: \
 144           http://$listen/each > $curl_out 2> $curl_err || > $ok
 145         dbgcat curl_err
 146         dbgcat curl_out
 147         grep 413 $curl_err
 148         test -e $ok
 149 }
 150
 151 t_begin "small size sha1 chunked ok (each)" && {
 152         blob_sha1=b376885ac8452b6cbf9ced81b1080bfd570d9b91
 153         rm -f $ok
 154         dd if=/dev/zero bs=256 count=1 | \
 155           curl -vsSf -T- -H Expect: \
 156           http://$listen/each > $curl_out 2> $curl_err
 157         dbgcat curl_err
 158         dbgcat curl_out
 159         test "$(cat $curl_out)" = $blob_sha1
 160 }
 161
 162 t_begin "small size sha1 content-length ok (each)" && {
 163         blob_sha1=b376885ac8452b6cbf9ced81b1080bfd570d9b91
 164         rm -f $ok
 165         dd if=/dev/zero bs=256 count=1 of=$tmp
 166         curl -vsSf -T $tmp -H Expect: \
 167           http://$listen/each > $curl_out 2> $curl_err
 168         dbgcat curl_err
 169         dbgcat curl_out
 170         test "$(cat $curl_out)" = $blob_sha1
 171 }
 172
 173 t_begin "stops a large line-based chunked request (each)" && {
 174         rm -f $ok
 175         </dev/null awk 'BEGIN{for(i=22;--i>=0;) print "hello world"}' | \
 176           curl -vsSf -T- -H Expect: \
 177           http://$listen/each > $curl_out 2> $curl_err || > $ok
 178         dbgcat curl_err
 179         dbgcat curl_out
 180         grep 413 $curl_err
 181         test -e $ok
 182 }
 183
 184 t_begin "OK with line-based chunked request (each)" && {
 185         rm -f $ok
 186         </dev/null awk 'BEGIN{for(i=21;--i>=0;) print "hello world"}' | \
 187           curl -vsSf -T- -H Expect: \
 188           http://$listen/each > $curl_out 2> $curl_err
 189         dbgcat curl_err
 190         dbgcat curl_out
 191         test x"$(cat $curl_out)" = x23eab3cebcbe22a0456c8462e3d3bb01ae761702
 192 }
 193
 194 t_begin "shutdown" && {
 195         kill $rainbows_pid
 196 }
 197
 198 t_done