puma-simon 3.7.1

data/test/test_events.rb

@@ -0,0 +1,161 @@
+require "test_helper"
+
+require "puma/events"
+
+class TestEvents < Minitest::Test
+  def test_null
+    events = Puma::Events.null
+
+    assert_instance_of Puma::NullIO, events.stdout
+    assert_instance_of Puma::NullIO, events.stderr
+    assert_equal events.stdout, events.stderr
+  end
+
+  def test_strings
+    events = Puma::Events.strings
+
+    assert_instance_of StringIO, events.stdout
+    assert_instance_of StringIO, events.stderr
+  end
+
+  def test_stdio
+    events = Puma::Events.stdio
+
+    assert_equal STDOUT, events.stdout
+    assert_equal STDERR, events.stderr
+  end
+
+  def test_register_callback_with_block
+    res = false
+
+    events = Puma::Events.null
+
+    events.register(:exec) { res = true }
+
+    events.fire(:exec)
+
+    assert_equal true, res
+  end
+
+  def test_register_callback_with_object
+    obj = Object.new
+
+    def obj.res
+      @res || false
+    end
+
+    def obj.call
+      @res = true
+    end
+
+    events = Puma::Events.null
+
+    events.register(:exec, obj)
+
+    events.fire(:exec)
+
+    assert_equal true, obj.res
+  end
+
+  def test_fire_callback_with_multiple_arguments
+    res = []
+
+    events = Puma::Events.null
+
+    events.register(:exec) { |*args| res.concat(args) }
+
+    events.fire(:exec, :foo, :bar, :baz)
+
+    assert_equal [:foo, :bar, :baz], res
+  end
+
+  def test_on_booted_callback
+    res = false
+
+    events = Puma::Events.null
+
+    events.on_booted { res = true }
+
+    events.fire_on_booted!
+
+    assert res
+  end
+
+  def test_log_writes_to_stdout
+    out, _ = capture_io do
+      Puma::Events.stdio.log("ready")
+    end
+
+    assert_equal "ready\n", out
+  end
+
+  def test_write_writes_to_stdout
+    out, _ = capture_io do
+      Puma::Events.stdio.write("ready")
+    end
+
+    assert_equal "ready", out
+  end
+
+  def test_debug_writes_to_stdout_if_env_is_present
+    original_debug, ENV["PUMA_DEBUG"] = ENV["PUMA_DEBUG"], "1"
+
+    out, _ = capture_io do
+      Puma::Events.stdio.debug("ready")
+    end
+
+    assert_equal "% ready\n", out
+  ensure
+    ENV["PUMA_DEBUG"] = original_debug
+  end
+
+  def test_debug_not_write_to_stdout_if_env_is_not_present
+    out, _ = capture_io do
+      Puma::Events.stdio.debug("ready")
+    end
+
+    assert_empty out
+  end
+
+  def test_error_writes_to_stderr_and_exits
+    did_exit = false
+
+    _, err = capture_io do
+      Puma::Events.stdio.error("interrupted")
+    end
+
+    assert_equal "ERROR: interrupted", err
+  rescue SystemExit
+    did_exit = true
+  ensure
+    assert did_exit
+  end
+
+  def test_pid_formatter
+    pid = Process.pid
+
+    out, _ = capture_io do
+      events = Puma::Events.stdio
+
+      events.formatter = Puma::Events::PidFormatter.new
+
+      events.write("ready")
+    end
+
+    assert_equal "[#{ pid }] ready", out
+  end
+
+  def test_custom_log_formatter
+    custom_formatter = proc { |str| "-> #{ str }" }
+
+    out, _ = capture_io do
+      events = Puma::Events.stdio
+
+      events.formatter = custom_formatter
+
+      events.write("ready")
+    end
+
+    assert_equal "-> ready", out
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,50 @@
+# Copyright (c) 2011 Evan Phoenix
+# Copyright (c) 2005 Zed A. Shaw
+
+require "bundler/setup"
+require "minitest/autorun"
+require "minitest/pride"
+require "puma"
+require "puma/detect"
+
+# Either takes a string to do a get request against, or a tuple of [URI, HTTP] where
+# HTTP is some kind of Net::HTTP request object (POST, HEAD, etc.)
+def hit(uris)
+  results = []
+
+  uris.each do |u|
+    res = nil
+
+    if u.kind_of? String
+      res = Net::HTTP.get(URI.parse(u))
+    else
+      url = URI.parse(u[0])
+      res = Net::HTTP.new(url.host, url.port).start {|h| h.request(u[1]) }
+    end
+
+    assert res != nil, "Didn't get a response: #{u}"
+    results << res
+  end
+
+  return results
+end
+
+module TimeoutEveryTestCase
+  def run(*)
+    if !!ENV['CI']
+      Timeout.timeout(60) { super }
+    else
+      super
+    end
+  end
+end
+
+Minitest::Test.prepend TimeoutEveryTestCase
+
+module SkipTestsBasedOnRubyEngine
+  def skip_on_jruby
+    skip "Skipped on JRuby" if Puma.jruby?
+  end
+end
+
+Minitest::Test.include SkipTestsBasedOnRubyEngine

data/test/test_http10.rb

@@ -0,0 +1,27 @@
+require "test_helper"
+
+require "puma/puma_http11"
+
+class Http10ParserTest < Minitest::Test
+  def test_parse_simple
+    parser = Puma::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,186 @@
+# Copyright (c) 2011 Evan Phoenix
+# Copyright (c) 2005 Zed A. Shaw
+
+require "test_helper"
+
+require "puma/puma_http11"
+
+class Http11ParserTest < Minitest::Test
+
+  def test_parse_simple
+    parser = Puma::HttpParser.new
+    req = {}
+    http = "GET /?a=1 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 '/?a=1', req['REQUEST_URI']
+    assert_equal 'GET', req['REQUEST_METHOD']
+    assert_nil req['FRAGMENT']
+    assert_equal "a=1", req['QUERY_STRING']
+
+    parser.reset
+    assert parser.nread == 0, "Number read after reset should be 0"
+  end
+
+  def test_parse_escaping_in_query
+    parser = Puma::HttpParser.new
+    req = {}
+    http = "GET /admin/users?search=%27%%27 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 '/admin/users?search=%27%%27', req['REQUEST_URI']
+    assert_equal "search=%27%%27", req['QUERY_STRING']
+
+    parser.reset
+    assert parser.nread == 0, "Number read after reset should be 0"
+  end
+
+  def test_parse_absolute_uri
+    parser = Puma::HttpParser.new
+    req = {}
+    http = "GET http://192.168.1.96:3000/api/v1/matches/test?1=1 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 "GET", req['REQUEST_METHOD']
+    assert_equal 'http://192.168.1.96:3000/api/v1/matches/test?1=1', req['REQUEST_URI']
+    assert_equal 'HTTP/1.1', req['HTTP_VERSION']
+
+    assert_nil req['REQUEST_PATH']
+    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 = Puma::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 = Puma::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 = Puma::HttpParser.new
+    req = {}
+    get = "GET /forums/1/topics/2375?page=1#posts-17408 HTTP/1.1\r\n\r\n"
+
+    parser.execute(req, get, 0)
+
+    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 = Puma::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(3000, 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 = Puma::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,247 @@
+require "test_helper"
+
+require "puma/cli"
+require "puma/control_cli"
+
+# These don't run on travis because they're too fragile
+
+class TestIntegration < Minitest::Test
+  def setup
+    @state_path = "test/test_puma.state"
+    @bind_path = "test/test_server.sock"
+    @control_path = "test/test_control.sock"
+    @token = "xxyyzz"
+    @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")
+
+    while (@server.gets) !~ /Ctrl-C/
+      # nothing
+    end
+
+    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 Puma.jruby? || Puma.windows?
+      assert true
+      return
+    end
+
+    conf = Puma::Configuration.new do |c|
+      c.quiet
+      c.state_path @state_path
+      c.bind "unix://#{@bind_path}"
+      c.activate_control_app "unix://#{@control_path}", :auth_token => @token
+      c.rackup "test/hello.ru"
+    end
+
+    l = Puma::Launcher.new conf, :events => @events
+
+    t = Thread.new do
+      Thread.current.abort_on_exception = true
+      l.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 test_phased_restart_via_pumactl
+    skip("Too finicky, fails 50% of the time on CI.")
+
+    if Puma.jruby? || Puma.windows?
+      assert true
+      return
+    end
+
+    conf = Puma::Configuration.new do |c|
+      c.quiet
+      c.state_path @state_path
+      c.bind "unix://#{@bind_path}"
+      c.activate_control_app "unix://#{@control_path}", :auth_token => @token
+      c.workers 2
+      c.worker_shutdown_timeout 1
+      c.rackup "test/hello-stuck.ru"
+    end
+
+    l = Puma::Launcher.new conf, :events => @events
+
+    Thread.abort_on_exception = true
+
+    t = Thread.new do
+      Thread.current.abort_on_exception = true
+      l.run
+    end
+
+    wait_booted
+
+    # Make both workers stuck
+    s1 = UNIXSocket.new @bind_path
+    s1 << "GET / HTTP/1.0\r\n\r\n"
+
+    sout = StringIO.new
+
+    # Phased restart
+    ccli = Puma::ControlCLI.new %W!-S #{@state_path} phased-restart!, sout
+    ccli.run
+    sleep 20
+    @events.stdout.rewind
+    log = @events.stdout.readlines.join("")
+    assert_match(/TERM sent/, log)
+    assert_match(/- Worker \d \(pid: \d+\) booted, phase: 1/, log)
+
+    # Stop
+    ccli = Puma::ControlCLI.new %W!-S #{@state_path} stop!, sout
+    ccli.run
+
+    assert_kind_of Thread, t.join(5), "server didn't stop"
+  end
+
+  def test_kill_unknown_via_pumactl
+    if Puma.jruby? || Puma.windows?
+      assert true
+      return
+    end
+
+    # we run ls to get a 'safe' pid to pass off as puma in cli stop
+    # do not want to accidently kill a valid other process
+    io = IO.popen("ls")
+    safe_pid = io.pid
+    Process.wait safe_pid
+
+    sout = StringIO.new
+
+    e = assert_raises SystemExit do
+      ccli = Puma::ControlCLI.new %W!-p #{safe_pid} stop!, sout
+      ccli.run
+    end
+    sout.rewind
+    assert_match(/No pid '\d+' found/, sout.readlines.join(""))
+    assert_equal(1, e.status)
+  end
+
+  def test_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
+
+    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
+
+    while (@server.gets) !~ /Ctrl-C/
+      # nothing
+    end
+
+    sleep 5 if Puma.jruby?
+
+    s = TCPSocket.new "127.0.0.1", @tcp_port
+    s << "GET / HTTP/1.0\r\n\r\n"
+    assert_equal "Hello World", s.read.split("\r\n").last
+  end
+
+  def test_restart_closes_keepalive_sockets_workers
+    if Puma.jruby?
+      assert true
+      return
+    end
+
+    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
+end