thin 1.7.2 → 2.0.0.pre

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

data/test/unit/response_test.rb

@@ -0,0 +1,90 @@
+require 'test_helper'
+require 'thin/response'
+
+class ResponseTest < Test::Unit::TestCase
+  def setup
+    @response = Thin::Response.new
+    @response.headers['Content-Type'] = 'text/html'
+    @response.headers['Content-Length'] = '0'
+    @response.body = ''
+    @response.finish
+  end
+
+  def test_initialize_with_values
+    @response = Thin::Response.new(201, {"Content-Type" => "text/plain"}, ["hi"])
+    assert_equal 201, @response.status
+    assert_match "Content-Type: text/plain", @response.headers.to_s
+    assert_equal ["hi"], @response.body
+  end
+
+  def test_output_headers
+    assert_match "Content-Type: text/html", @response.headers.to_s
+    assert_match "Content-Length: 0", @response.headers.to_s
+    assert_match "Connection: close", @response.headers.to_s
+  end
+
+  def test_include_server_name_header
+    assert_match "Server: thin", @response.headers.to_s
+  end
+
+  def test_output_head
+    assert_match /^HTTP\/1.1 200 OK/, @response.head
+    assert_match /\r\n\r\n$/, @response.head
+  end
+
+  def test_allow_duplicates_on_some_headers
+    @response.headers['Set-Cookie'] = 'mium=7'
+    @response.headers['Set-Cookie'] = 'hi=there'
+
+    assert_match "Set-Cookie: mium=7", @response.head
+    assert_match "Set-Cookie: hi=there", @response.head
+  end
+
+  def test_parse_simple_header_values
+    @response.headers = {
+      'Host' => 'localhost'
+    }
+
+    assert_match "Host: localhost", @response.head
+  end
+
+  def test_parse_multiline_header_values_in_several_headers
+    @response.headers = {
+      'Set-Cookie' => "mium=7\nhi=there"
+    }
+
+    assert_match "Set-Cookie: mium=7", @response.head
+    assert_match "Set-Cookie: hi=there", @response.head
+  end
+
+  def test_ignore__nil_headers
+    @response.headers = nil
+    @response.headers = { 'Host' => 'localhost' }
+    @response.headers = { 'Set-Cookie' => nil }
+    assert_no_match /Set-Cookie/, @response.head
+  end
+
+  def test_body
+    @response.body = ['<html>', '</html>']
+
+    out = ''
+    @response.each { |l| out << l }
+    assert_match /\r\n\r\n<html><\/html>$/, out
+  end
+
+  def test_string_body
+    @response.body = '<html></html>'
+
+    out = ''
+    @response.each { |l| out << l }
+    assert_match /\r\n\r\n<html><\/html>$/, out
+  end
+
+  def test_close
+    @response.close
+  end
+  
+  def test_async
+    assert Thin::Response.new(*Thin::Response::ASYNC).async?
+  end
+end

data/test/unit/server_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+class ServerTest < Test::Unit::TestCase
+  def setup
+    app = proc { |env| [200, {}, ["ok"]] }
+    @server = Thin::Server.new { app }
+  end
+
+  def test_pick_prefork_backend_if_any_workers
+    @server.worker_processes = 1
+    assert_kind_of Thin::Backends::Prefork, @server.backend
+  end
+
+  def test_pick_single_process_backend_if_no_workers
+    @server.worker_processes = 0
+    assert_kind_of Thin::Backends::SingleProcess, @server.backend
+  end
+
+  def test_cant_daemonize_single_process
+    @server.worker_processes = 0
+    assert_raise(NotImplementedError) do
+      silence_streams { @server.start(true) }
+    end
+  end
+  
+  def test_do_not_preload_app
+    Thin::Server.new { fail "Should not load app before starting" }
+  end
+end

data/test/unit/system_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+class SystemTest < Test::Unit::TestCase
+  def test_processor_count
+    assert_not_equal 0, Thin::System.processor_count
+  end
+
+  if Thin::System.java? || Thin::System.win?
+    def test_should_not_support_fork
+      assert ! Thin::System.supports_fork?
+    end
+  else
+    def test_should_support_fork
+      assert Thin::System.supports_fork?
+    end
+  end
+end

data/thin.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "thin/version"
+
+Gem::Specification.new do |s|
+  s.name        = "thin"
+  s.version     = Thin::VERSION::STRING
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Marc-Andre Cournoyer"]
+  s.email       = ["thin@macournoyer.com"]
+  s.homepage    = "http://code.macournoyer.com/thin"
+  s.summary     = %q{A thin and fast web server}
+  s.description = %q{Thin is a Rack based, high performance web server}
+
+  s.rubyforge_project = "thin"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_dependency "eventmachine-le", "~> 1.1.0"
+  s.add_dependency "http_parser.rb", "~> 0.5.3"
+  s.add_dependency "preforker", "~> 0.1.1"
+  s.add_dependency "rack", "~> 1.4"
+end