puma 2.0.0.b5 → 5.0.0.beta1

data/test/test_config.rb

@@ -1,16 +0,0 @@
-require 'test/unit'
-
-require 'puma'
-require 'puma/configuration'
-
-class TestConfigFile < Test::Unit::TestCase
-  def test_app_from_app_DSL
-    opts = { :config_file => "test/config/app.rb" }
-    conf = Puma::Configuration.new opts
-    conf.load
-
-    app = conf.app
-
-    assert_equal [200, {}, ["embedded app"]], app.call(nil)
-  end
-end

data/test/test_http10.rb

@@ -1,27 +0,0 @@
-require 'test/testhelp'
-
-class Http10ParserTest < Test::Unit::TestCase
-  include Puma
-
-  def test_parse_simple
-    parser = HttpParser.new
-    req = {}
-    http = "GET / HTTP/1.0\r\n\r\n"
-    nread = parser.execute(req, http, 0)
-
-    assert nread == http.length, "Failed to parse the full HTTP request"
-    assert parser.finished?, "Parser didn't finish"
-    assert !parser.error?, "Parser had error"
-    assert nread == parser.nread, "Number read returned from execute does not match"
-
-    assert_equal '/', req['REQUEST_PATH']
-    assert_equal 'HTTP/1.0', req['HTTP_VERSION']
-    assert_equal '/', req['REQUEST_URI']
-    assert_equal 'GET', req['REQUEST_METHOD']    
-    assert_nil req['FRAGMENT']
-    assert_nil req['QUERY_STRING']
-    
-    parser.reset
-    assert parser.nread == 0, "Number read after reset should be 0"
-  end
-end

data/test/test_http11.rb

@@ -1,126 +0,0 @@
-# Copyright (c) 2011 Evan Phoenix
-# Copyright (c) 2005 Zed A. Shaw 
-
-require 'test/testhelp'
-
-include Puma
-
-class Http11ParserTest < Test::Unit::TestCase
-
-  def test_parse_simple
-    parser = HttpParser.new
-    req = {}
-    http = "GET / HTTP/1.1\r\n\r\n"
-    nread = parser.execute(req, http, 0)
-
-    assert nread == http.length, "Failed to parse the full HTTP request"
-    assert parser.finished?, "Parser didn't finish"
-    assert !parser.error?, "Parser had error"
-    assert nread == parser.nread, "Number read returned from execute does not match"
-
-    assert_equal '/', req['REQUEST_PATH']
-    assert_equal 'HTTP/1.1', req['HTTP_VERSION']
-    assert_equal '/', req['REQUEST_URI']
-    assert_equal 'GET', req['REQUEST_METHOD']    
-    assert_nil req['FRAGMENT']
-    assert_nil req['QUERY_STRING']
-    
-    parser.reset
-    assert parser.nread == 0, "Number read after reset should be 0"
-  end
- 
-  def test_parse_dumbfuck_headers
-    parser = HttpParser.new
-    req = {}
-    should_be_good = "GET / HTTP/1.1\r\naaaaaaaaaaaaa:++++++++++\r\n\r\n"
-    nread = parser.execute(req, should_be_good, 0)
-    assert_equal should_be_good.length, nread
-    assert parser.finished?
-    assert !parser.error?
-  end
-  
-  def test_parse_error
-    parser = HttpParser.new
-    req = {}
-    bad_http = "GET / SsUTF/1.1"
-
-    error = false
-    begin
-      parser.execute(req, bad_http, 0)
-    rescue
-      error = true
-    end
-
-    assert error, "failed to throw exception"
-    assert !parser.finished?, "Parser shouldn't be finished"
-    assert parser.error?, "Parser SHOULD have error"
-  end
-
-  def test_fragment_in_uri
-    parser = HttpParser.new
-    req = {}
-    get = "GET /forums/1/topics/2375?page=1#posts-17408 HTTP/1.1\r\n\r\n"
-    assert_nothing_raised do
-      parser.execute(req, get, 0)
-    end
-    assert parser.finished?
-    assert_equal '/forums/1/topics/2375?page=1', req['REQUEST_URI']
-    assert_equal 'posts-17408', req['FRAGMENT']
-  end
-
-  # lame random garbage maker
-  def rand_data(min, max, readable=true)
-    count = min + ((rand(max)+1) *10).to_i
-    res = count.to_s + "/"
-    
-    if readable
-      res << Digest::SHA1.hexdigest(rand(count * 100).to_s) * (count / 40)
-    else
-      res << Digest::SHA1.digest(rand(count * 100).to_s) * (count / 20)
-    end
-
-    return res
-  end
-  
-
-  def test_horrible_queries
-    parser = HttpParser.new
-
-    # then that large header names are caught
-    10.times do |c|
-      get = "GET /#{rand_data(10,120)} HTTP/1.1\r\nX-#{rand_data(1024, 1024+(c*1024))}: Test\r\n\r\n"
-      assert_raises Puma::HttpParserError do
-        parser.execute({}, get, 0)
-        parser.reset
-      end
-    end
-
-    # then that large mangled field values are caught
-    10.times do |c|
-      get = "GET /#{rand_data(10,120)} HTTP/1.1\r\nX-Test: #{rand_data(1024, 1024+(c*1024), false)}\r\n\r\n"
-      assert_raises Puma::HttpParserError do
-        parser.execute({}, get, 0)
-        parser.reset
-      end
-    end
-
-    # then large headers are rejected too
-    get = "GET /#{rand_data(10,120)} HTTP/1.1\r\n"
-    get << "X-Test: test\r\n" * (80 * 1024)
-    assert_raises Puma::HttpParserError do
-      parser.execute({}, get, 0)
-      parser.reset
-    end
-
-    # finally just that random garbage gets blocked all the time
-    10.times do |c|
-      get = "GET #{rand_data(1024, 1024+(c*1024), false)} #{rand_data(1024, 1024+(c*1024), false)}\r\n\r\n"
-      assert_raises Puma::HttpParserError do
-        parser.execute({}, get, 0)
-        parser.reset
-      end
-    end
-
-  end
-end
-

data/test/test_integration.rb

@@ -1,150 +0,0 @@
-require "rbconfig"
-require 'test/unit'
-require 'socket'
-require 'timeout'
-require 'net/http'
-require 'tempfile'
-
-require 'puma/cli'
-require 'puma/control_cli'
-
-# These don't run on travis because they're too fragile
-
-class TestIntegration < Test::Unit::TestCase
-  def setup
-    @state_path = "test/test_puma.state"
-    @bind_path = "test/test_server.sock"
-    @control_path = "test/test_control.sock"
-    @tcp_port = 9998
-
-    @server = nil
-    @script = nil
-  end
-
-  def teardown
-    File.unlink @state_path rescue nil
-    File.unlink @bind_path  rescue nil
-    File.unlink @control_path rescue nil
-
-    if @server
-      Process.kill "INT", @server.pid
-      Process.wait @server.pid
-      @server.close
-    end
-
-    if @script
-      @script.close!
-    end
-  end
-
-  def server(opts)
-    core = "#{Gem.ruby} -rubygems -Ilib bin/puma"
-    cmd = "#{core} --restart-cmd '#{core}' -b tcp://127.0.0.1:#{@tcp_port} #{opts}"
-    tf = Tempfile.new "puma-test"
-    tf.puts "exec #{cmd}"
-    tf.close
-
-    @script = tf
-
-    @server = IO.popen("sh #{tf.path}", "r")
-
-    true while @server.gets =~ /Ctrl-C/
-
-    sleep 1
-
-    @server
-  end
-
-  def signal(which)
-    Process.kill which, @server.pid
-  end
-
-  def test_stop_via_pumactl
-    if defined?(JRUBY_VERSION) || RbConfig::CONFIG["host_os"] =~ /mingw|mswin/
-      assert true
-      return
-    end
-
-    sin = StringIO.new
-    sout = StringIO.new
-
-    cli = Puma::CLI.new %W!-q -S #{@state_path} -b unix://#{@bind_path} --control unix://#{@control_path} test/hello.ru!, sin, sout
-
-    t = Thread.new do
-      cli.run
-    end
-
-    sleep 1
-
-    s = UNIXSocket.new @bind_path
-    s << "GET / HTTP/1.0\r\n\r\n"
-    assert_equal "Hello World", s.read.split("\r\n").last
-
-    ccli = Puma::ControlCLI.new %W!-S #{@state_path} stop!, sout
-
-    ccli.run
-
-    assert_kind_of Thread, t.join(1), "server didn't stop"
-  end
-
-  def notest_restart_closes_keepalive_sockets
-    server("-q test/hello.ru")
-
-    s = TCPSocket.new "localhost", @tcp_port
-    s << "GET / HTTP/1.1\r\n\r\n"
-    true until s.gets == "\r\n"
-
-    s.readpartial(20)
-    signal :USR2
-
-    true while @server.gets =~ /Ctrl-C/
-    sleep 1
-
-    s.write "GET / HTTP/1.1\r\n\r\n"
-
-    assert_raises Errno::ECONNRESET do
-      Timeout.timeout(2) do
-        raise Errno::ECONNRESET unless s.read(2)
-      end
-    end
-
-    s = TCPSocket.new "localhost", @tcp_port
-    s << "GET / HTTP/1.0\r\n\r\n"
-    assert_equal "Hello World", s.read.split("\r\n").last
-  end
-
-  def notest_restart_closes_keepalive_sockets_workers
-    server("-q -w 2 test/hello.ru")
-
-    s = TCPSocket.new "localhost", @tcp_port
-    s << "GET / HTTP/1.1\r\n\r\n"
-    true until s.gets == "\r\n"
-
-    s.readpartial(20)
-    signal :USR2
-
-    true while @server.gets =~ /Ctrl-C/
-    sleep 1
-
-    s.write "GET / HTTP/1.1\r\n\r\n"
-
-    assert_raises Errno::ECONNRESET do
-      Timeout.timeout(2) do
-        raise Errno::ECONNRESET unless s.read(2)
-      end
-    end
-
-    s = TCPSocket.new "localhost", @tcp_port
-    s << "GET / HTTP/1.0\r\n\r\n"
-    assert_equal "Hello World", s.read.split("\r\n").last
-  end
-
-  def test_bad_query_string_outputs_400
-    server "-q test/hello.ru 2>&1"
-
-    s = TCPSocket.new "localhost", @tcp_port
-    s << "GET /?h=% HTTP/1.0\r\n\r\n"
-    data = s.read
-    assert_equal "HTTP/1.1 400 Bad Request\r\n\r\n", data
-  end
-end unless ENV['TRAVIS']

data/test/test_iobuffer.rb

@@ -1,38 +0,0 @@
-require 'puma/io_buffer'
-require 'test/unit'
-
-class TestIOBuffer < Test::Unit::TestCase
-  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

@@ -1,22 +0,0 @@
-require 'test/unit'
-
-require 'puma'
-require 'puma/minissl'
-
-class TestMiniSSL < Test::Unit::TestCase
-
-  def test_raises_with_invalid_key_file
-    ctx = Puma::MiniSSL::Context.new
-
-    exception = assert_raise(ArgumentError) { ctx.key = "/no/such/key" }
-    assert_equal("No such key file '/no/such/key'", exception.message)
-  end unless defined? JRUBY_VERSION
-
-  def test_raises_with_invalid_cert_file
-    ctx = Puma::MiniSSL::Context.new
-
-    exception = assert_raise(ArgumentError) { ctx.cert = "/no/such/cert" }
-    assert_equal("No such cert file '/no/such/cert'", exception.message)
-  end unless defined? JRUBY_VERSION
-
-end

data/test/test_null_io.rb

@@ -1,31 +0,0 @@
-require 'puma/null_io'
-require 'test/unit'
-
-class TestNullIO < Test::Unit::TestCase
-  attr_accessor :nio
-  def setup
-    self.nio = Puma::NullIO.new
-  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
-end

data/test/test_persistent.rb

@@ -1,238 +0,0 @@
-require 'puma'
-require 'test/unit'
-require 'timeout'
-
-class TestPersistent < Test::Unit::TestCase
-  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(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_no_chunked_in_http10
-    @body << "Chunked"
-
-    @client << @http10_request
-
-    assert_equal "HTTP/1.0 200 OK\r\nX-Header: Works\r\nConnection: close\r\n\r\n", lines(4)
-    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\nConnection: close\r\nContent-Length: #{sz}\r\n\r\n", lines(5)
-    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