puma-simon 3.7.1

data/test/test_iobuffer.rb

@@ -0,0 +1,39 @@
+require "test_helper"
+
+require "puma/io_buffer"
+
+class TestIOBuffer < Minitest::Test
+  attr_accessor :iobuf
+  def setup
+    self.iobuf = Puma::IOBuffer.new
+  end
+
+  def test_initial_size
+    assert_equal 0, iobuf.used
+    assert iobuf.capacity > 0
+  end
+
+  def test_append_op
+    iobuf << "abc"
+    assert_equal "abc", iobuf.to_s
+    iobuf << "123"
+    assert_equal "abc123", iobuf.to_s
+    assert_equal 6, iobuf.used
+  end
+
+  def test_append
+    expected = "mary had a little lamb"
+    iobuf.append("mary", " ", "had ", "a little", " lamb")
+    assert_equal expected, iobuf.to_s
+    assert_equal expected.length, iobuf.used
+  end
+
+  def test_reset
+    iobuf << "content"
+    assert_equal "content", iobuf.to_s
+    iobuf.reset
+    assert_equal 0, iobuf.used
+    assert_equal "", iobuf.to_s
+  end
+
+end

data/test/test_minissl.rb

@@ -0,0 +1,29 @@
+require "test_helper"
+
+require "puma/minissl"
+
+class TestMiniSSL < Minitest::Test
+
+  if Puma.jruby?
+    def test_raises_with_invalid_keystore_file
+      ctx = Puma::MiniSSL::Context.new
+
+      exception = assert_raises(ArgumentError) { ctx.keystore = "/no/such/keystore" }
+      assert_equal("No such keystore file '/no/such/keystore'", exception.message)
+    end
+  else
+    def test_raises_with_invalid_key_file
+      ctx = Puma::MiniSSL::Context.new
+
+      exception = assert_raises(ArgumentError) { ctx.key = "/no/such/key" }
+      assert_equal("No such key file '/no/such/key'", exception.message)
+    end
+
+    def test_raises_with_invalid_cert_file
+      ctx = Puma::MiniSSL::Context.new
+
+      exception = assert_raises(ArgumentError) { ctx.cert = "/no/such/cert" }
+      assert_equal("No such cert file '/no/such/cert'", exception.message)
+    end
+  end
+end

data/test/test_null_io.rb

@@ -0,0 +1,49 @@
+require "test_helper"
+
+require "puma/null_io"
+
+class TestNullIO < Minitest::Test
+  attr_accessor :nio
+
+  def setup
+    self.nio = Puma::NullIO.new
+  end
+
+  def test_eof_returns_true
+    assert nio.eof?
+  end
+
+  def test_gets_returns_nil
+    assert_nil nio.gets
+  end
+
+  def test_each_never_yields
+    nio.each { raise "never yield" }
+  end
+
+  def test_read_with_no_arguments
+    assert_equal "", nio.read
+  end
+
+  def test_read_with_nil_length
+    assert_equal "", nio.read(nil)
+  end
+
+  def test_read_with_zero_length
+    assert_equal "", nio.read(0)
+  end
+
+  def test_read_with_positive_integer_length
+    assert_nil nio.read(1)
+  end
+
+  def test_read_with_length_and_buffer
+    buf = ""
+    assert_nil nio.read(1, buf)
+    assert_equal "", buf
+  end
+
+  def test_size
+    assert_equal 0, nio.size
+  end
+end

data/test/test_persistent.rb

@@ -0,0 +1,245 @@
+require "test_helper"
+
+class TestPersistent < Minitest::Test
+  def setup
+    @valid_request = "GET / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+    @close_request = "GET / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\nConnection: close\r\n\r\n"
+    @http10_request = "GET / HTTP/1.0\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+    @keep_request = "GET / HTTP/1.0\r\nHost: test.com\r\nContent-Type: text/plain\r\nConnection: Keep-Alive\r\n\r\n"
+
+    @valid_post = "POST / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\nContent-Length: 5\r\n\r\nhello"
+    @valid_no_body = "GET / HTTP/1.1\r\nHost: test.com\r\nX-Status: 204\r\nContent-Type: text/plain\r\n\r\n"
+
+    @headers = { "X-Header" => "Works" }
+    @body = ["Hello"]
+    @inputs = []
+
+    @simple = lambda do |env|
+      @inputs << env['rack.input']
+      status = Integer(env['HTTP_X_STATUS'] || 200)
+      [status, @headers, @body]
+    end
+
+    @host = "127.0.0.1"
+    @port = 9988
+
+    @server = Puma::Server.new @simple
+    @server.add_tcp_listener "127.0.0.1", 9988
+    @server.max_threads = 1
+    @server.run
+
+    @client = TCPSocket.new "127.0.0.1", 9988
+  end
+
+  def teardown
+    @client.close
+    @server.stop(true)
+  end
+
+  def lines(count, s=@client)
+    str = ""
+    Timeout.timeout(5) do
+      count.times { str << s.gets }
+    end
+    str
+  end
+
+  def test_one_with_content_length
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nContent-Length: #{sz}\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_two_back_to_back
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nContent-Length: #{sz}\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nContent-Length: #{sz}\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_post_then_get
+    @client << @valid_post
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nContent-Length: #{sz}\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nContent-Length: #{sz}\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_no_body_then_get
+    @client << @valid_no_body
+    assert_equal "HTTP/1.1 204 No Content\r\nX-Header: Works\r\n\r\n", lines(3)
+
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nContent-Length: #{sz}\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_chunked
+    @body << "Chunked"
+
+    @client << @valid_request
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nHello\r\n7\r\nChunked\r\n0\r\n\r\n", lines(10)
+  end
+
+  def test_chunked_with_empty_part
+    @body << ""
+    @body << "Chunked"
+
+    @client << @valid_request
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nHello\r\n7\r\nChunked\r\n0\r\n\r\n", lines(10)
+  end
+
+  def test_no_chunked_in_http10
+    @body << "Chunked"
+
+    @client << @http10_request
+
+    assert_equal "HTTP/1.0 200 OK\r\nX-Header: Works\r\n\r\n", lines(3)
+    assert_equal "HelloChunked", @client.read
+  end
+
+  def test_hex
+    str = "This is longer and will be in hex"
+    @body << str
+
+    @client << @valid_request
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nHello\r\n#{str.size.to_s(16)}\r\n#{str}\r\n0\r\n\r\n", lines(10)
+
+  end
+
+  def test_client11_close
+    @client << @close_request
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nConnection: close\r\nContent-Length: #{sz}\r\n\r\n", lines(5)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_client10_close
+    @client << @http10_request
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.0 200 OK\r\nX-Header: Works\r\nContent-Length: #{sz}\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_one_with_keep_alive_header
+    @client << @keep_request
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.0 200 OK\r\nX-Header: Works\r\nConnection: Keep-Alive\r\nContent-Length: #{sz}\r\n\r\n", lines(5)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_persistent_timeout
+    @server.persistent_timeout = 2
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nContent-Length: #{sz}\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+
+    sleep 3
+
+    assert_raises EOFError do
+      @client.read_nonblock(1)
+    end
+  end
+
+  def test_app_sets_content_length
+    @body = ["hello", " world"]
+    @headers['Content-Length'] = "11"
+
+    @client << @valid_request
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nContent-Length: 11\r\n\r\n",
+                 lines(4)
+    assert_equal "hello world", @client.read(11)
+  end
+
+  def test_allow_app_to_chunk_itself
+    @headers = {'Transfer-Encoding' => "chunked" }
+
+    @body = ["5\r\nhello\r\n0\r\n\r\n"]
+
+    @client << @valid_request
+
+    assert_equal "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nhello\r\n0\r\n\r\n", lines(7)
+  end
+
+
+  def test_two_requests_in_one_chunk
+    @server.persistent_timeout = 3
+
+    req = @valid_request.to_s
+    req << "GET /second HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+
+    @client << req
+
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nContent-Length: #{sz}\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nContent-Length: #{sz}\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_second_request_not_in_first_req_body
+    @server.persistent_timeout = 3
+
+    req = @valid_request.to_s
+    req << "GET /second HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+
+    @client << req
+
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nContent-Length: #{sz}\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nContent-Length: #{sz}\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+
+    assert_kind_of Puma::NullIO, @inputs[0]
+    assert_kind_of Puma::NullIO, @inputs[1]
+  end
+
+  def test_keepalive_doesnt_starve_clients
+    sz = @body[0].size.to_s
+
+    @client << @valid_request
+
+    c2 = TCPSocket.new @host, @port
+    c2 << @valid_request
+
+    out = IO.select([c2], nil, nil, 1)
+
+    assert out, "select returned nil"
+    assert_equal c2, out.first.first
+
+    assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nContent-Length: #{sz}\r\n\r\n", lines(4, c2)
+    assert_equal "Hello", c2.read(5)
+  end
+
+end

data/test/test_puma_server.rb

@@ -0,0 +1,626 @@
+require "test_helper"
+
+class TestPumaServer < Minitest::Test
+
+  def setup
+    @port = 0
+    @host = "127.0.0.1"
+
+    @app = lambda { |env| [200, {}, [env['rack.url_scheme']]] }
+
+    @events = Puma::Events.new STDOUT, STDERR
+    @server = Puma::Server.new @app, @events
+  end
+
+  def teardown
+    @server.stop(true)
+  end
+
+  def header(sock)
+    header = []
+    while true
+      line = sock.gets
+      break if line == "\r\n"
+      header << line.strip
+    end
+
+    header
+  end
+
+  def test_proper_stringio_body
+    data = nil
+
+    @server.app = proc do |env|
+      data = env['rack.input'].read
+      [200, {}, ["ok"]]
+    end
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    fifteen = "1" * 15
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "PUT / HTTP/1.0\r\nContent-Length: 30\r\n\r\n#{fifteen}"
+    sleep 0.1 # important so that the previous data is sent as a packet
+    sock << fifteen
+
+    sock.read
+
+    assert_equal "#{fifteen}#{fifteen}", data
+  end
+
+  def test_puma_socket
+    body = "HTTP/1.1 750 Upgraded to Awesome\r\nDone: Yep!\r\n"
+    @server.app = proc do |env|
+      io = env['puma.socket']
+
+      io.write body
+
+      io.close
+
+      [-1, {}, []]
+    end
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "PUT / HTTP/1.0\r\n\r\nHello"
+
+    assert_equal body, sock.read
+  end
+
+  def test_very_large_return
+    giant = "x" * 2056610
+
+    @server.app = proc do |env|
+      [200, {}, [giant]]
+    end
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.0\r\n\r\n"
+
+    while true
+      line = sock.gets
+      break if line == "\r\n"
+    end
+
+    out = sock.read
+
+    assert_equal giant.bytesize, out.bytesize
+  end
+
+  def test_respect_x_forwarded_proto
+    @server.app = proc do |env|
+      [200, {}, [env['SERVER_PORT']]]
+    end
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    req = Net::HTTP::Get.new("/")
+    req['HOST'] = "example.com"
+    req['X_FORWARDED_PROTO'] = "https"
+
+    res = Net::HTTP.start @host, @server.connected_port do |http|
+      http.request(req)
+    end
+
+    assert_equal "443", res.body
+  end
+
+  def test_default_server_port
+    @server.app = proc do |env|
+      [200, {}, [env['SERVER_PORT']]]
+    end
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    req = Net::HTTP::Get.new("/")
+    req['HOST'] = "example.com"
+
+    res = Net::HTTP.start @host, @server.connected_port do |http|
+      http.request(req)
+    end
+
+    assert_equal "80", res.body
+  end
+
+  def test_HEAD_has_no_body
+    @server.app = proc { |env| [200, {"Foo" => "Bar"}, ["hello"]] }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "HEAD / HTTP/1.0\r\n\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.0 200 OK\r\nFoo: Bar\r\nContent-Length: 5\r\n\r\n", data
+  end
+
+  def test_GET_with_empty_body_has_sane_chunking
+    @server.app = proc { |env| [200, {}, [""]] }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "HEAD / HTTP/1.0\r\n\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.0 200 OK\r\nContent-Length: 0\r\n\r\n", data
+  end
+
+  def test_GET_with_no_body_has_sane_chunking
+    @server.app = proc { |env| [200, {}, []] }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "HEAD / HTTP/1.0\r\n\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.0 200 OK\r\n\r\n", data
+  end
+
+  def test_doesnt_print_backtrace_in_production
+    @events = Puma::Events.strings
+    @server = Puma::Server.new @app, @events
+
+    @server.app = proc { |e| raise "don't leak me bro" }
+    @server.leak_stack_on_error = false
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.0\r\n\r\n"
+
+    data = sock.read
+
+    refute_match(/don't leak me bro/, data)
+    assert_match(/HTTP\/1.0 500 Internal Server Error/, data)
+  end
+
+  def test_prints_custom_error
+    @events = Puma::Events.strings
+    re = lambda { |err| [302, {'Content-Type' => 'text', 'Location' => 'foo.html'}, ['302 found']] }
+    @server = Puma::Server.new @app, @events, {:lowlevel_error_handler => re}
+
+    @server.app = proc { |e| raise "don't leak me bro" }
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.0\r\n\r\n"
+
+    data = sock.read
+    assert_match(/HTTP\/1.0 302 Found/, data)
+  end
+
+  def test_leh_gets_env_as_well
+    @events = Puma::Events.strings
+    re = lambda { |err,env|
+      env['REQUEST_PATH'] || raise("where is env?")
+      [302, {'Content-Type' => 'text', 'Location' => 'foo.html'}, ['302 found']]
+    }
+
+    @server = Puma::Server.new @app, @events, {:lowlevel_error_handler => re}
+
+    @server.app = proc { |e| raise "don't leak me bro" }
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.0\r\n\r\n"
+
+    data = sock.read
+    assert_match(/HTTP\/1.0 302 Found/, data)
+  end
+
+  def test_custom_http_codes_10
+    @server.app = proc { |env| [449, {}, [""]] }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+
+    sock << "GET / HTTP/1.0\r\n\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.0 449 CUSTOM\r\nContent-Length: 0\r\n\r\n", data
+  end
+
+  def test_custom_http_codes_11
+    @server.app = proc { |env| [449, {}, [""]] }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.1\r\nConnection: close\r\n\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.1 449 CUSTOM\r\nConnection: close\r\nContent-Length: 0\r\n\r\n", data
+  end
+
+  def test_HEAD_returns_content_headers
+    @server.app = proc { |env| [200, {"Content-Type" => "application/pdf",
+                                      "Content-Length" => "4242"}, []] }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+
+    sock << "HEAD / HTTP/1.0\r\n\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.0 200 OK\r\nContent-Type: application/pdf\r\nContent-Length: 4242\r\n\r\n", data
+  end
+
+  def test_status_hook_fires_when_server_changes_states
+
+    states = []
+
+    @events.register(:state) { |s| states << s }
+
+    @server.app = proc { |env| [200, {}, [""]] }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "HEAD / HTTP/1.0\r\n\r\n"
+
+    sock.read
+
+    assert_equal [:booting, :running], states
+
+    @server.stop(true)
+
+    assert_equal [:booting, :running, :stop, :done], states
+  end
+
+  def test_timeout_in_data_phase
+    skip("Hangs too often, TODO: fix")
+
+    @server.first_data_timeout = 2
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    client = TCPSocket.new @host, @server.connected_port
+
+    client << "POST / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\nContent-Length: 5\r\n\r\n"
+
+    data = client.gets
+
+    assert_equal "HTTP/1.1 408 Request Timeout\r\n", data
+  end
+
+  def test_http_11_keep_alive_with_body
+    @server.app = proc { |env| [200, {"Content-Type" => "plain/text"}, ["hello\n"]] }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.1\r\nConnection: Keep-Alive\r\n\r\n"
+
+    h = header(sock)
+
+    body = sock.gets
+
+    assert_equal ["HTTP/1.1 200 OK", "Content-Type: plain/text", "Content-Length: 6"], h
+    assert_equal "hello\n", body
+
+    sock.close
+  end
+
+  def test_http_11_close_with_body
+    @server.app = proc { |env| [200, {"Content-Type" => "plain/text"}, ["hello"]] }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.1\r\nConnection: close\r\n\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.1 200 OK\r\nContent-Type: plain/text\r\nConnection: close\r\nContent-Length: 5\r\n\r\nhello", data
+  end
+
+  def test_http_11_keep_alive_without_body
+    @server.app = proc { |env| [204, {}, []] }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.1\r\nConnection: Keep-Alive\r\n\r\n"
+
+    h = header(sock)
+
+    sock.close
+
+    assert_equal ["HTTP/1.1 204 No Content"], h
+  end
+
+  def test_http_11_close_without_body
+    @server.app = proc { |env| [204, {}, []] }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.1\r\nConnection: close\r\n\r\n"
+
+    h = header(sock)
+
+    sock.close
+
+    assert_equal ["HTTP/1.1 204 No Content", "Connection: close"], h
+  end
+
+  def test_http_10_keep_alive_with_body
+    @server.app = proc { |env| [200, {"Content-Type" => "plain/text"}, ["hello\n"]] }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.0\r\nConnection: Keep-Alive\r\n\r\n"
+
+    h = header(sock)
+
+    body = sock.gets
+
+    assert_equal ["HTTP/1.0 200 OK", "Content-Type: plain/text", "Connection: Keep-Alive", "Content-Length: 6"], h
+    assert_equal "hello\n", body
+
+    sock.close
+  end
+
+  def test_http_10_close_with_body
+    @server.app = proc { |env| [200, {"Content-Type" => "plain/text"}, ["hello"]] }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.0\r\nConnection: close\r\n\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.0 200 OK\r\nContent-Type: plain/text\r\nContent-Length: 5\r\n\r\nhello", data
+  end
+
+  def test_http_10_partial_hijack_with_content_length
+    body_parts = ['abc', 'de']
+
+    @server.app = proc do |env|
+      hijack_lambda = proc do | io |
+        io.write(body_parts[0])
+        io.write(body_parts[1])
+        io.close
+      end
+      [200, {"Content-Length" => "5", 'rack.hijack' => hijack_lambda}, nil]
+    end
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.0\r\nConnection: close\r\n\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.0 200 OK\r\nContent-Length: 5\r\n\r\nabcde", data
+  end
+
+  def test_http_10_keep_alive_without_body
+    @server.app = proc { |env| [204, {}, []] }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.0\r\nConnection: Keep-Alive\r\n\r\n"
+
+    h = header(sock)
+
+    assert_equal ["HTTP/1.0 204 No Content", "Connection: Keep-Alive"], h
+
+    sock.close
+  end
+
+  def test_http_10_close_without_body
+    @server.app = proc { |env| [204, {}, []] }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.0\r\nConnection: close\r\n\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.0 204 No Content\r\n\r\n", data
+  end
+
+  def test_Expect_100
+    @server.app = proc { |env| [200, {}, [""]] }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.1\r\nConnection: close\r\nExpect: 100-continue\r\n\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.1 100 Continue\r\n\r\nHTTP/1.1 200 OK\r\nConnection: close\r\nContent-Length: 0\r\n\r\n", data
+  end
+
+  def test_chunked_request
+    body = nil
+    @server.app = proc { |env|
+      body = env['rack.input'].read
+      [200, {}, [""]]
+    }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.1\r\nConnection: close\r\nTransfer-Encoding: chunked\r\n\r\n1\r\nh\r\n4\r\nello\r\n0\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Length: 0\r\n\r\n", data
+    assert_equal "hello", body
+  end
+
+  def test_chunked_request_pause_before_value
+    body = nil
+    @server.app = proc { |env|
+      body = env['rack.input'].read
+      [200, {}, [""]]
+    }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.1\r\nConnection: close\r\nTransfer-Encoding: chunked\r\n\r\n1\r\n"
+    sleep 1
+
+    sock << "h\r\n4\r\nello\r\n0\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Length: 0\r\n\r\n", data
+    assert_equal "hello", body
+  end
+
+  def test_chunked_request_pause_between_chunks
+    body = nil
+    @server.app = proc { |env|
+      body = env['rack.input'].read
+      [200, {}, [""]]
+    }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.1\r\nConnection: close\r\nTransfer-Encoding: chunked\r\n\r\n1\r\nh\r\n"
+    sleep 1
+
+    sock << "4\r\nello\r\n0\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Length: 0\r\n\r\n", data
+    assert_equal "hello", body
+  end
+
+  def test_chunked_request_pause_mid_count
+    body = nil
+    @server.app = proc { |env|
+      body = env['rack.input'].read
+      [200, {}, [""]]
+    }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.1\r\nConnection: close\r\nTransfer-Encoding: chunked\r\n\r\n1\r"
+    sleep 1
+
+    sock << "\nh\r\n4\r\nello\r\n0\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Length: 0\r\n\r\n", data
+    assert_equal "hello", body
+  end
+
+  def test_chunked_request_pause_before_count_newline
+    body = nil
+    @server.app = proc { |env|
+      body = env['rack.input'].read
+      [200, {}, [""]]
+    }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.1\r\nConnection: close\r\nTransfer-Encoding: chunked\r\n\r\n1"
+    sleep 1
+
+    sock << "\r\nh\r\n4\r\nello\r\n0\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Length: 0\r\n\r\n", data
+    assert_equal "hello", body
+  end
+
+  def test_chunked_request_pause_mid_value
+    body = nil
+    @server.app = proc { |env|
+      body = env['rack.input'].read
+      [200, {}, [""]]
+    }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.1\r\nConnection: close\r\nTransfer-Encoding: chunked\r\n\r\n1\r\nh\r\n4\r\ne"
+    sleep 1
+
+    sock << "llo\r\n0\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Length: 0\r\n\r\n", data
+    assert_equal "hello", body
+  end
+
+  def test_chunked_request_header_case
+    body = nil
+    @server.app = proc { |env|
+      body = env['rack.input'].read
+      [200, {}, [""]]
+    }
+
+    @server.add_tcp_listener @host, @port
+    @server.run
+
+    sock = TCPSocket.new @host, @server.connected_port
+    sock << "GET / HTTP/1.1\r\nConnection: close\r\nTransfer-Encoding: Chunked\r\n\r\n1\r\nh\r\n4\r\nello\r\n0\r\n"
+
+    data = sock.read
+
+    assert_equal "HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Length: 0\r\n\r\n", data
+    assert_equal "hello", body
+  end
+end