wendell-puma 2.9.2

data/test/test_cli.rb

@@ -0,0 +1,173 @@
+require "rbconfig"
+require 'test/unit'
+require 'puma/cli'
+require 'tempfile'
+
+class TestCLI < Test::Unit::TestCase
+  def setup
+    @environment = 'production'
+    @tmp_file = Tempfile.new("puma-test")
+    @tmp_path = @tmp_file.path
+    @tmp_file.close!
+
+    @tmp_path2 = "#{@tmp_path}2"
+
+    File.unlink @tmp_path if File.exist? @tmp_path
+    File.unlink @tmp_path2 if File.exist? @tmp_path2
+
+    @wait, @ready = IO.pipe
+
+    @events = Events.strings
+    @events.on_booted { @ready << "!" }
+  end
+
+  def wait_booted
+    @wait.sysread 1
+  end
+
+  def teardown
+    File.unlink @tmp_path if File.exist? @tmp_path
+    File.unlink @tmp_path2 if File.exist? @tmp_path2
+
+    @wait.close
+    @ready.close
+  end
+
+  def test_pid_file
+    cli = Puma::CLI.new ["--pidfile", @tmp_path]
+    cli.parse_options
+    cli.write_pid
+
+    assert_equal File.read(@tmp_path).strip.to_i, Process.pid
+  end
+
+  def test_control_for_tcp
+    url = "tcp://127.0.0.1:9877/"
+    cli = Puma::CLI.new ["-b", "tcp://127.0.0.1:9876",
+                         "--control", url,
+                         "--control-token", "",
+                         "test/lobster.ru"], @events
+
+    cli.parse_options
+
+    thread_exception = nil
+    t = Thread.new do
+      begin
+        cli.run
+      rescue Exception => e
+        thread_exception = e
+      end
+    end 
+
+    wait_booted
+
+    s = TCPSocket.new "127.0.0.1", 9877
+    s << "GET /stats HTTP/1.0\r\n\r\n"
+    body = s.read
+    assert_equal '{ "backlog": 0, "running": 0 }', body.split("\r\n").last
+
+    cli.stop
+    t.join
+    assert_equal nil, thread_exception
+  end
+
+  unless defined?(JRUBY_VERSION) || RbConfig::CONFIG["host_os"] =~ /mingw|mswin/
+  def test_control
+    url = "unix://#{@tmp_path}"
+
+    cli = Puma::CLI.new ["-b", "unix://#{@tmp_path2}",
+                         "--control", url,
+                         "--control-token", "",
+                         "test/lobster.ru"], @events
+    cli.parse_options
+
+    t = Thread.new { cli.run }
+
+    wait_booted
+
+    s = UNIXSocket.new @tmp_path
+    s << "GET /stats HTTP/1.0\r\n\r\n"
+    body = s.read
+
+    assert_equal '{ "backlog": 0, "running": 0 }', body.split("\r\n").last
+
+    cli.stop
+    t.join
+  end
+
+  def test_control_stop
+    url = "unix://#{@tmp_path}"
+
+    cli = Puma::CLI.new ["-b", "unix://#{@tmp_path2}",
+                         "--control", url,
+                         "--control-token", "",
+                         "test/lobster.ru"], @events
+    cli.parse_options
+
+    t = Thread.new { cli.run }
+
+    wait_booted
+
+    s = UNIXSocket.new @tmp_path
+    s << "GET /stop HTTP/1.0\r\n\r\n"
+    body = s.read
+
+    assert_equal '{ "status": "ok" }', body.split("\r\n").last
+
+    t.join
+  end
+
+  def test_tmp_control
+    url = "tcp://127.0.0.1:8232"
+    cli = Puma::CLI.new ["--state", @tmp_path, "--control", "auto"]
+    cli.parse_options
+    cli.write_state
+
+    data = YAML.load File.read(@tmp_path)
+
+    assert_equal Process.pid, data["pid"]
+
+    url = data["config"].options[:control_url]
+
+    m = %r!unix://(.*)!.match(url)
+
+    assert m, "'#{url}' is not a URL"
+  end
+  end # JRUBY or Windows
+
+  def test_state
+    url = "tcp://127.0.0.1:8232"
+    cli = Puma::CLI.new ["--state", @tmp_path, "--control", url]
+    cli.parse_options
+    cli.write_state
+
+    data = YAML.load File.read(@tmp_path)
+
+    assert_equal Process.pid, data["pid"]
+    assert_equal url, data["config"].options[:control_url]
+  end
+
+  def test_load_path
+    cli = Puma::CLI.new ["--include", 'foo/bar']
+    cli.parse_options
+
+    assert_equal 'foo/bar', $LOAD_PATH[0]
+    $LOAD_PATH.shift
+
+    cli = Puma::CLI.new ["--include", 'foo/bar:baz/qux']
+    cli.parse_options
+
+    assert_equal 'foo/bar', $LOAD_PATH[0]
+    $LOAD_PATH.shift
+    assert_equal 'baz/qux', $LOAD_PATH[0]
+    $LOAD_PATH.shift
+  end
+
+  def test_environment
+    cli = Puma::CLI.new ["--environment", @environment]
+    cli.parse_options
+    cli.set_rack_environment
+
+    assert_equal ENV['RACK_ENV'], @environment 
+  end
+end

data/test/test_config.rb

@@ -0,0 +1,26 @@
+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({})
+  end
+
+  def test_lowleve_error_handler_DSL
+    opts = { :config_file => "test/config/app.rb" }
+    conf = Puma::Configuration.new opts
+    conf.load
+
+    app = conf.options[:lowlevel_error_handler]
+
+    assert_equal [200, {}, ["error page"]], app.call({})
+  end
+end

data/test/test_http10.rb

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,144 @@
+# Copyright (c) 2011 Evan Phoenix
+# Copyright (c) 2005 Zed A. Shaw
+
+require '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_max_uri_path_length
+    parser = HttpParser.new
+    req = {}
+
+    # Support URI path length to a max of 2048
+    path = "/" + rand_data(1000, 100)
+    http = "GET #{path} HTTP/1.1\r\n\r\n"
+    parser.execute(req, http, 0)
+    assert_equal path, req['REQUEST_PATH']
+    parser.reset
+
+    # Raise exception if URI path length > 2048
+    path = "/" + rand_data(2049, 100)
+    http = "GET #{path} HTTP/1.1\r\n\r\n"
+    assert_raises Puma::HttpParserError do
+      parser.execute(req, http, 0)
+      parser.reset
+    end
+  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

@@ -0,0 +1,165 @@
+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
+
+    @wait, @ready = IO.pipe
+
+    @events = Puma::Events.strings
+    @events.on_booted { @ready << "!" }
+  end
+
+  def teardown
+    File.unlink @state_path rescue nil
+    File.unlink @bind_path  rescue nil
+    File.unlink @control_path rescue nil
+
+    @wait.close
+    @ready.close
+
+    if @server
+      Process.kill "INT", @server.pid
+      begin
+        Process.wait @server.pid
+      rescue Errno::ECHILD
+      end
+
+      @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 wait_booted
+    @wait.sysread 1
+  end
+
+  def test_stop_via_pumactl
+    if defined?(JRUBY_VERSION) || RbConfig::CONFIG["host_os"] =~ /mingw|mswin/
+      assert true
+      return
+    end
+
+    cli = Puma::CLI.new %W!-q -S #{@state_path} -b unix://#{@bind_path} --control unix://#{@control_path} test/hello.ru!, @events
+
+    t = Thread.new do
+      cli.run
+    end
+
+    wait_booted
+
+    s = UNIXSocket.new @bind_path
+    s << "GET / HTTP/1.0\r\n\r\n"
+    assert_equal "Hello World", s.read.split("\r\n").last
+
+    sout = StringIO.new
+
+    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']