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

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