thin 1.8.0 → 2.0.0.pre

data/test/integration/config.ru

@@ -0,0 +1,57 @@
+require "thin/async"
+
+class App
+  def call(env)
+    request = Rack::Request.new(env)
+    
+    case request.path_info
+    when "/"
+      Rack::Response.new do |response|
+        response.write "ok"
+      end.finish
+      
+    when "/env"
+      Rack::Response.new do |response|
+        env.each_pair do |key, value|
+          response.write "#{key}: #{value}\n"
+        end
+        response.write "\n" + request.body.read
+      end.finish
+      
+    when "/eval"
+      Rack::Response.new do |response|
+        response.write eval(request["code"]).to_s
+      end.finish
+      
+    when "/raise"
+      raise "ouch"
+      
+    when "/exit"
+      exit!
+      
+    when "/sleep"
+      sleep request["sec"].to_f
+      
+    when "/async"
+      Thin::AsyncResponse.new(env) do |response|
+        response << "one\n"
+        EM.next_tick do
+          response << "two\n"
+          response.done # close the connection
+        end
+      end.finish
+      
+    else
+      Rack::Response.new do |response|
+        response.status = 404
+        response.write "not found"
+      end.finish
+      
+    end
+  end
+end
+
+use Rack::Static, :urls => ["/small.txt", "/big.txt"],
+                  :root => File.expand_path("../../fixtures", __FILE__)
+
+run App.new

data/test/integration/daemonize_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class DaemonizeTest < IntegrationTestCase
+  def test_do_not_daemonize
+    pid = thin
+
+    assert_equal @pid, pid, "Launcher PID should be the same as master PID"
+    Process.kill 0, @pid
+
+    get "/"
+
+    assert_status 200
+  end
+
+  def test_daemonize
+    pid = thin :daemonize => true
+
+    assert_not_equal @pid, pid, "Launcher PID should not be the same as master PID"
+    Process.kill 0, pid
+    Process.kill 0, @pid
+
+    get "/"
+
+    assert_status 200
+  end
+end

data/test/integration/env_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class EnvTest < IntegrationTestCase
+  def test_get
+    thin
+
+    get '/env?hi=there'
+
+    assert_status 200
+    assert_response_includes "REMOTE_ADDR: 127.0.0.1"
+    assert_response_includes "SERVER_SOFTWARE: thin"
+    assert_response_includes "HTTP_HOST: localhost:8181"
+    assert_response_includes "SERVER_PORT: 8181"
+    assert_response_includes "SERVER_NAME: localhost"
+    assert_response_includes "REQUEST_METHOD: GET"
+    assert_response_includes "PATH_INFO: /env"
+    assert_response_includes "QUERY_STRING: hi=there"
+    assert_response_includes "rack.url_scheme: http"
+    assert_response_includes "rack.multithread: false"
+    assert_response_includes "rack.multiprocess: true"
+    assert_response_includes "rack.run_once: false"
+  end
+
+  def test_post
+    thin
+
+    post '/env', :hi => "there"
+
+    assert_status 200
+    assert_response_includes "REMOTE_ADDR: 127.0.0.1"
+    assert_response_includes "SERVER_SOFTWARE: thin"
+    assert_response_includes "HTTP_HOST: localhost:8181"
+    assert_response_includes "SERVER_PORT: 8181"
+    assert_response_includes "SERVER_NAME: localhost"
+    assert_response_includes "REQUEST_METHOD: POST"
+    assert_response_includes "PATH_INFO: /env"
+    assert_response_includes "QUERY_STRING: \n"
+    assert_response_includes "rack.url_scheme: http"
+    assert_response_includes "rack.multithread: false"
+    assert_response_includes "rack.multiprocess: true"
+    assert_response_includes "rack.run_once: false"
+    assert_response_includes "\n\nhi=there"
+  end
+end

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