thin 1.8.2 → 2.0.0.pre

data/test/integration/error_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class ErrorTest < IntegrationTestCase
+  def test_raise
+    thin :log => "/dev/null"
+
+    get "/raise"
+
+    assert_status 500
+  end
+
+  def test_raise_without_middlewares
+    thin :env => "none", :log => "/dev/null"
+
+    get "/raise"
+
+    assert_status 500
+  end
+
+  def test_logs_errors
+    thin :env => "none"
+
+    get "/raise"
+    assert_match "[ERROR] ouch", read_log
+  end
+
+  def test_parse_error
+    thin :log => "/dev/null"
+
+    socket do |s|
+      s.write "!!!WTH??YO111!\r\n"
+      s.flush
+
+      assert_match "HTTP/1.1 400 Bad Request", s.read
+    end
+  end
+end

data/test/integration/file_sending_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class FileSendingTest < IntegrationTestCase
+  def test_small_file
+    thin :env => "none"
+
+    get "/small.txt"
+
+    assert_status 200
+    assert_header "Transfer-Encoding", "chunked"
+    assert_equal File.size(File.expand_path("../../fixtures/small.txt", __FILE__)), @response.body.size
+  end
+  
+  def test_big_file
+    thin :env => "none"
+    
+    # Just big enough (>16K) to trigger EM mapped streamer.
+    get "/big.txt"
+
+    assert_status 200
+    assert_header "Transfer-Encoding", "chunked"
+    assert_equal File.size(File.expand_path("../../fixtures/big.txt", __FILE__)), @response.body.size
+  end
+end

data/test/integration/keep_alive_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class KeepAliveTest < IntegrationTestCase
+  def test_enabled_by_default_on_http_1_1
+    thin
+
+    get '/'
+
+    assert_status 200
+    assert_header "Connection", "keep-alive"
+  end
+  
+  def test_disabled_on_http_1_0
+    thin
+
+    socket do |s|
+      s.write("GET / HTTP/1.0\r\n")
+      s.write("\r\n")
+      s.flush
+      
+      assert_match "Connection: close", s.readpartial(1024)
+    end
+  end
+  
+  def test_limited
+    thin do
+      keep_alive_requests 0
+    end
+
+    get '/'
+
+    assert_status 200
+    assert_header "Connection", "close"
+  end
+end

data/test/integration/robustness_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class RobustnessTest < IntegrationTestCase
+  def test_should_not_crash_when_header_too_large
+    thin :log => "/dev/null"
+
+    100.times do
+      begin
+        socket do |s|
+          s.write("GET / HTTP/1.1\r\n")
+          s.write("Host: localhost\r\n")
+          s.write("Connection: close\r\n")
+          10000.times do
+            s.write("X-Foo: #{'x' * 100}\r\n")
+            s.flush
+          end
+          s.write("\r\n")
+          s.read
+        end
+      rescue Errno::EPIPE, Errno::ECONNRESET
+        # Ignore.
+      end
+    end
+  end
+
+  def test_incomplete_request
+    thin do
+      timeout 1
+    end
+
+    socket do |s|
+      s.write "GET /?this HTTP/1.1\r\n"
+      s.write "Host:"
+      assert_equal "", s.read
+    end
+  end
+end

data/test/integration/single_process_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class SingleProcessTest < IntegrationTestCase
+  def test_stop_with_int_signal
+    thin :env => "none" do
+      worker_processes 0
+    end
+
+    Process.kill "INT", @pid
+    _, status = Process.wait2 @pid
+    @pid = nil
+
+    assert status.success?
+  end
+end

data/test/integration/socket_family_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class SocketFamilyTest < IntegrationTestCase
+  def test_ipv4
+    thin do
+      listen PORT
+    end
+
+    get "/"
+
+    assert_status 200
+    assert_response_equals "ok"
+    assert_header "Content-Type", "text/html"
+  end
+
+  def test_ipv6
+    thin do
+      listen "[::]:#{PORT}"
+    end
+
+    get "/"
+
+    assert_status 200
+    assert_response_equals "ok"
+    assert_header "Content-Type", "text/html"
+  end
+
+  def test_unix_socket
+    thin do
+      listen UNIX_SOCKET
+    end
+
+    unix_socket do |s|
+      s.write "GET / HTTP/1.1\r\n\r\n"
+      assert_match "HTTP/1.1 200 OK", s.read
+    end
+  end
+end

data/test/integration/worker_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+class WorkerTest < IntegrationTestCase
+  def test_restart_worker_on_exit
+    thin do
+      worker_processes 1
+    end
+
+    assert_raise(EOFError) { get "/exit" }
+    get "/"
+
+    assert_status 200
+  end
+
+  def test_timeout
+    thin do
+      timeout 1
+    end
+
+    assert_raise(EOFError) { get "/sleep?sec=2" }
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,195 @@
+require "bundler/setup"
+Bundler.require(:default, :test)
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "thin"
+require "test/unit"
+require "mocha"
+require "net/http"
+require "timeout"
+
+class Test::Unit::TestCase
+  include Mocha::API # fix mocha API not being included in minitest
+
+  # Silences any stream for the duration of the block.
+  #
+  #   silence_stream(STDOUT) do
+  #     puts 'This will never be seen'
+  #   end
+  #
+  #   puts 'But this will'
+  #
+  # (Taken from ActiveSupport)
+  def silence_stream(stream)
+    old_stream = stream.dup
+    stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+    stream.sync = true
+    yield
+  ensure
+    stream.reopen(old_stream)
+  end
+
+  def silence_streams
+    silence_stream($stdout) { silence_stream($stderr) { yield } }
+  end
+
+  def capture_streams
+    out = StringIO.new
+    silence_streams do
+      $stdout = out
+      $stderr = out
+      yield
+      out.read
+    end
+  ensure
+    $stdout = STDOUT
+    $stderr = STDERR
+  end
+end
+
+class ConfigWriter < BasicObject
+  def initialize(&block)
+    @lines = []
+    instance_eval(&block) if block
+  end
+
+  def method_missing(name, *args)
+    @lines << name.to_s + " " + args.map { |arg| arg.inspect }.join(", ")
+  end
+
+  def write(file)
+    ::File.open(file, "w") do |f|
+      f << "# Generated during tests by ConfigWriter in test_helper.rb\n"
+      f << @lines.join("\n")
+    end
+  end
+end
+
+class IntegrationTestCase < Test::Unit::TestCase
+  PORT = 8181
+  UNIX_SOCKET = "/tmp/thin-test.sock"
+  LOG_FILE = "test.log"
+  PID_FILE = "test.pid"
+
+  # Start a new thin server from the command line utility mimicing real world usage.
+  # @param runner_options Options to pass to the command line utility.
+  # @param configuration Block of configuration to pass to the configurator.
+  def thin(runner_options={}, &configuration)
+    raise "Server already started in process #" + File.read(PID_FILE) if File.exist?(PID_FILE)
+
+    # Cleanup
+    File.delete LOG_FILE if File.exist?(LOG_FILE)
+    File.delete UNIX_SOCKET if File.exist?(UNIX_SOCKET)
+
+    root = File.expand_path('../..', __FILE__)
+
+    # Generate a config file from the configuration block
+    config_file = "test.conf.rb"
+    config = ConfigWriter.new do
+      worker_processes 1
+    end
+    config.instance_eval(&configuration) if configuration
+    config.write(config_file)
+
+    # Command line options
+    runner_options = { :config => config_file, :port => PORT, :log => LOG_FILE, :pid => PID_FILE }.merge(runner_options)
+
+    # Launch the server from the shell
+    command = "bundle exec ruby -I#{root}/lib " +
+                "#{root}/bin/thin " +
+                  runner_options.map { |k, v| (k.size > 1 ? "-" : "") + "-#{k}" + (TrueClass === v ? "" : "=#{v}") }.join(" ") + " " +
+                  File.expand_path("../integration/config.ru", __FILE__)
+    launcher_pid = silence_stream($stdout) { spawn command }
+
+    tries = 0
+    wait = 5 #sec
+    until running?
+      sleep 0.1
+      tries += 1
+      raise "Failed to start server under #{wait} sec" if tries > wait/0.1
+    end
+
+    @pid = File.read(PID_FILE).to_i
+
+    launcher_pid
+  end
+
+  def teardown
+    if @pid
+      Process.kill "INT", @pid
+      begin
+        Process.wait @pid
+      rescue Errno::ECHILD
+        # Process is not a child. We ping until process dies.
+        sleep 0.1 while Process.kill 0, @pid rescue false
+      end
+      @pid = nil
+    end
+    raise "Didn't delete PID file." if File.exist?(PID_FILE)
+    @response = nil
+  end
+  
+  def running?
+    return true if File.exist?(UNIX_SOCKET)
+    get("/")
+    true
+  rescue Errno::ECONNREFUSED
+    false
+  rescue
+    true
+  end
+
+  def get(path, host="localhost")
+    @response = Timeout.timeout(3) { Net::HTTP.get_response(URI.parse("http://#{host}:#{PORT}" + path)) }
+  end
+
+  def post(path, params={})
+    Timeout.timeout(3) do
+      uri = URI.parse("http://localhost:#{PORT}" + path)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request.set_form_data(params)
+
+      @response = http.request(request)
+    end
+  end
+
+  def socket
+    @response = nil
+    socket = TCPSocket.new("localhost", PORT)
+    yield socket
+  ensure
+    socket.close rescue nil
+  end
+
+  def unix_socket
+    @response = nil
+    socket = UNIXSocket.new(UNIX_SOCKET)
+    yield socket
+  ensure
+    socket.close rescue nil
+  end
+
+  def assert_status(status)
+    assert_equal status, @response.code.to_i
+  end
+
+  def assert_response_equals(string)
+    assert_equal string, @response.body
+  end
+
+  def assert_response_includes(*strings)
+    strings.each do |string|
+      assert @response.body.include?(string), "expected response to include #{string}, but got: #{@response.body}"
+    end
+  end
+
+  def assert_header(key, value)
+    assert_equal value, @response[key]
+  end
+
+  def read_log
+    File.read(LOG_FILE)
+  end
+end

data/test/unit/configurator_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+require "thin/configurator"
+
+class ConfiguratorTest < Test::Unit::TestCase
+  def setup
+    @config = Thin::Configurator.new
+  end
+
+  def test_worker_processes
+    @config.worker_processes 5
+    assert_equal 5, @config.options[:worker_processes]
+    assert_raise(ArgumentError) { @config.worker_processes "5" }
+  end
+
+  def test_use_epoll
+    @config.use_epoll true
+    @config.use_epoll false
+    assert_raise(ArgumentError) { @config.use_epoll 1 }
+  end
+
+  def test_listen
+    @config.listen 3000
+    @config.listen "0.0.0.0:3000"
+    assert_raise(ArgumentError) { @config.listen false }
+    assert_equal 2, @config.options[:listeners].size
+  end
+
+  def test_before_fork
+    @config.before_fork { :ok }
+    assert_equal :ok, @config.options[:before_fork].call(:server)
+  end
+
+  def test_load_from_file
+    Thin::Configurator.load(File.expand_path("../../fixtures/thin.conf.rb", __FILE__))
+  end
+
+  def test_apply
+    server = Thin::Server.new {}
+    @config.worker_processes 10000
+    @config.apply(server)
+    assert_equal 10000, server.worker_processes
+  end
+end

data/test/unit/connection_test.rb

@@ -0,0 +1,94 @@
+require 'test_helper'
+require 'thin/connection'
+
+class ConnectionTest < Test::Unit::TestCase
+  def setup
+    @connection = Thin::Connection.new(nil)
+    @connection.server = self
+    @connection.post_init
+
+    @connection.stubs(:send_data)
+    @connection.stubs(:close_connection_after_writing)
+    @connection.stubs(:socket_address).returns("127.0.0.1")
+  end
+
+  #### Server methods
+  def app
+    proc do |env|
+      [200, {"Content-Type" => "text/plain"}, ["ok"]]
+    end
+  end
+  def threaded?; false end
+  def prefork?; false end
+  ####
+
+  def teardown
+    @connection.unbind
+  end
+
+  def test_send_response_body
+    request = <<-EOS
+GET / HTTP/1.1
+Host: localhost:3000
+
+EOS
+
+    @connection.expects(:send_data).with(includes("Content-Type: text/plain"))
+    @connection.expects(:send_data).with("ok")
+    @connection.expects(:close_connection_after_writing).once
+
+    @connection.receive_data(request)
+  end
+
+  def test_parse_get_request
+    request = <<-EOS
+GET /path?yo=dude HTTP/1.1
+Host: localhost:3000
+X-Special: awesome
+
+EOS
+
+    @connection.expects(:process)
+    @connection.receive_data(request)
+    
+    env = @connection.request.env
+    
+    assert_equal "GET", env["REQUEST_METHOD"]
+    assert_equal "/path", env["PATH_INFO"]
+    assert_equal "HTTP/1.1", env["SERVER_PROTOCOL"]
+    assert_equal "HTTP/1.1", env["HTTP_VERSION"]
+    assert_equal "yo=dude", env["QUERY_STRING"]
+    assert_equal "localhost:3000", env["HTTP_HOST"]
+    assert_equal "awesome", env["HTTP_X_SPECIAL"]
+    
+    # rack. values
+    assert_respond_to env["rack.input"], :read
+    assert_equal "http", env["rack.url_scheme"]
+  end
+  
+  def test_parse_post_request
+    request = <<-EOS
+POST /path HTTP/1.1
+Host: localhost:3000
+Content-Type: text/plain
+Content-Length: 2
+
+hi
+EOS
+
+    @connection.expects(:process)
+    @connection.receive_data(request)
+    
+    env = @connection.request.env
+    
+    assert_equal "POST", env["REQUEST_METHOD"]
+    assert_equal "/path", env["PATH_INFO"]
+    assert_equal "hi", env["rack.input"].read
+  end
+  
+  def test_async_response_do_not_send_response
+    @connection.expects(:send_response).never
+    
+    @connection.process_response(Thin::Response::ASYNC)
+  end
+end

data/test/unit/listener_test.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+class ListenerTest < Test::Unit::TestCase
+  def test_parse_integer_port_addresses
+    listener = Thin::Listener.new(3000)
+    assert_equal "", listener.host
+    assert_equal 3000, listener.port
+  end
+
+  def test_parse_star_port_addresses
+    listener = Thin::Listener.new("*:3000")
+    assert_equal "", listener.host
+    assert_equal 3000, listener.port
+  end
+
+  def test_parse_ipv4_and_port
+    listener = Thin::Listener.new("127.0.0.1:3000")
+    assert_equal "127.0.0.1", listener.host
+    assert_equal 3000, listener.port
+  end
+
+  def test_parse_ipv6_and_port
+    listener = Thin::Listener.new("[::]:3000")
+    assert_equal "::", listener.host
+    assert_equal 3000, listener.port
+  end
+
+  def test_parse_unix_socket
+    listener = Thin::Listener.new("/file.sock")
+    assert_nil listener.host
+    assert_nil listener.port
+    assert_equal "/file.sock", listener.socket_file
+  end
+
+  def test_parse_relative_unix_socket_with_prefix
+    listener = Thin::Listener.new("unix:file.sock")
+    assert_nil listener.host
+    assert_nil listener.port
+    assert_equal "file.sock", listener.socket_file
+  end
+
+  def test_parse_invalid_address
+    assert_raise(ArgumentError) { Thin::Listener.new("file.sock") }
+  end
+
+  def test_ipv4_socket
+    listener = Thin::Listener.new(3000)
+    assert_kind_of Socket, listener.socket
+  ensure
+    listener.close
+  end
+
+  def test_ipv6_socket
+    listener = Thin::Listener.new("[::]:3000")
+    assert_kind_of Socket, listener.socket
+  ensure
+    listener.close
+  end
+
+  def test_unix_socket
+    listener = Thin::Listener.new("/tmp/thin-test.sock")
+    assert_kind_of Socket, listener.socket
+  ensure
+    listener.close
+    assert ! File.exist?("tmp/thin-test.sock")
+  end
+
+  def test_set_socket_option
+    listener = Thin::Listener.new(3000, :tcp_no_delay => true)
+    assert listener.socket.getsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY)
+  ensure
+    listener.close
+  end
+end

data/test/unit/request_test.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+require "thin/request"
+require "rack"
+
+class RequestTest < Test::Unit::TestCase
+  def setup
+    @request = Thin::Request.new
+  end
+
+  def test_env_contains_requires_rack_variables
+    assert_respond_to @request.env['rack.input'], :read
+    assert_kind_of IO, @request.env['rack.errors']
+    assert_equal [1, 1], @request.env['rack.version']
+  end
+
+  def test_convert_parser_headers_to_rack_env
+    @request.headers = {
+      "Host" => "localhost:9292",
+      "Connection" => "close"
+    }
+
+    assert_equal "localhost:9292", @request.env["HTTP_HOST"]
+    assert_equal "close", @request.env["HTTP_CONNECTION"]
+    assert ! @request.env.key?("HOST")
+    assert ! @request.env.key?("CONNECTION")
+  end
+
+  def test_do_not_prefix_content_type_and_length
+    @request.headers = {
+      "Content-Type" => "text/html",
+      "Content-Length" => "1"
+    }
+
+    assert ! @request.env.key?("HTTP_CONTENT_TYPE")
+    assert ! @request.env.key?("HTTP_CONTENT_LENGTH")
+    assert_equal "text/html", @request.env["CONTENT_TYPE"]
+    assert_equal "1", @request.env["CONTENT_LENGTH"]
+  end
+
+  def test_extracts_server_name_and_port_from_host
+    @request.headers = {
+      "Host" => "localhost:3000"
+    }
+    assert_equal "localhost", @request.env["SERVER_NAME"]
+    assert_equal "3000", @request.env["SERVER_PORT"]
+  end
+
+  def test_defaults_server_name_and_port
+    @request.headers = {}
+    assert_equal "localhost", @request.env["SERVER_NAME"]
+    assert_equal "80", @request.env["SERVER_PORT"]
+  end
+
+  def test_validate_through_rack_lint
+    @request.multithread = false
+    @request.multiprocess = false
+    @request.method = "GET"
+    @request.path = "/info"
+    @request.fragment = "hello"
+    @request.query_string = "hey=there&yo=dude"
+    @request.headers = {
+      "Host" => "localhost:9292",
+      "Connection" => "close",
+      "Content-Type" => "text/plain"
+    }
+    @request.body << "ok"
+
+    app = proc do |env|
+      [200, {"Content-Type" => "text/plain"}, ["ok"]]
+    end
+
+    assert_nothing_raised { Rack::Lint.new(app).call(@request.env) }
+  end
+end