thin 1.3.1 → 1.4.0

data/spec/server/stopping_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-describe Server, "stopping" do
-  before do
-    start_server do |env|
-      [200, { 'Content-Type' => 'text/html' }, ['ok']]
-    end
-    @done = false
-  end
-  
-  it "should wait for current requests before soft stopping" do
-    socket = TCPSocket.new('0.0.0.0', 3333)
-    socket.write("GET / HTTP/1.1")
-    EventMachine.next_tick do
-      @server.stop # Stop the server in the middle of a request
-      socket.write("\r\n\r\n")
-      @done = true
-    end
-    
-    timeout(2) do
-      Thread.pass until @done
-    end
-    
-    out = socket.read
-    socket.close
-    
-    out.should_not be_empty
-  end
-  
-  it "should not accept new requests when soft stopping" do
-    socket = TCPSocket.new('0.0.0.0', 3333)
-    socket.write("GET / HTTP/1.1")
-    @server.stop # Stop the server in the middle of a request
-    
-    EventMachine.next_tick do
-      proc { get('/') }.should raise_error(Errno::ECONNRESET)
-    end
-    
-    socket.close
-  end
-  
-  it "should drop current requests when hard stopping" do
-    socket = TCPSocket.new('0.0.0.0', 3333)
-    socket.write("GET / HTTP/1.1")
-    @server.stop! # Force stop the server in the middle of a request
-    
-    EventMachine.next_tick do
-      socket.should be_closed
-    end
-  end
-  
-  after do
-    stop_server
-  end
-end

data/spec/server/swiftiply.yml

@@ -1,6 +0,0 @@
-cluster_address: 0.0.0.0
-cluster_port: 3333
-map:
-  - incoming: 127.0.0.1
-    outgoing: 127.0.0.1:5555
-    default: true 

data/spec/server/swiftiply_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-if SWIFTIPLY_PATH.empty?
-  warn "Ignoring Server on Swiftiply specs, gem install swiftiply to run"
-else
-  describe Server, 'on Swiftiply' do
-    before do
-      @swiftiply = fork do
-        exec "#{SWIFTIPLY_PATH} -c #{File.dirname(__FILE__)}/swiftiply.yml"
-      end
-      wait_for_socket('0.0.0.0', 3333)
-      sleep 2 # HACK ooh boy, I wish I knew how to make those specs more stable...
-      start_server('0.0.0.0', 5555, :backend => Backends::SwiftiplyClient, :wait_for_socket => false) do |env|
-        body = env.inspect + env['rack.input'].read
-        [200, { 'Content-Type' => 'text/html' }, body]
-      end
-    end
-    
-    it 'should GET from Net::HTTP' do
-      Net::HTTP.get(URI.parse("http://0.0.0.0:3333/?cthis")).should include('cthis')
-    end
-  
-    it 'should POST from Net::HTTP' do
-      Net::HTTP.post_form(URI.parse("http://0.0.0.0:3333/"), :arg => 'pirate').body.should include('arg=pirate')
-    end
-  
-    after do
-      stop_server
-      Process.kill(9, @swiftiply)
-    end
-  end
-end

data/spec/server/tcp_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe Server, 'on TCP socket' do
-  before do
-    start_server do |env|
-      body = env.inspect + env['rack.input'].read
-      [200, { 'Content-Type' => 'text/html' }, body]
-    end
-  end
-  
-  it 'should GET from Net::HTTP' do
-    get('/?cthis').should include('cthis')
-  end
-  
-  it 'should GET from TCPSocket' do
-    status, headers, body = parse_response(send_data("GET /?this HTTP/1.0\r\nConnection: close\r\n\r\n"))
-    status.should == 200
-    headers['Content-Type'].should == 'text/html'
-    headers['Connection'].should == 'close'
-    body.should include('this')
-  end
-  
-  it 'should return empty string on incomplete headers' do
-    send_data("GET /?this HTTP/1.1\r\nHost:").should be_empty
-  end
-  
-  it 'should return empty string on incorrect Content-Length' do
-    send_data("POST / HTTP/1.1\r\nContent-Length: 300\r\nConnection: close\r\n\r\naye").should be_empty
-  end
-  
-  it 'should POST from Net::HTTP' do
-    post('/', :arg => 'pirate').should include('arg=pirate')
-  end
-  
-  it 'should handle big POST' do
-    big = 'X' * (20 * 1024)
-    post('/', :big => big).should include(big)
-  end
-  
-  it "should retreive remote address" do
-    get('/').should include('"REMOTE_ADDR"=>"127.0.0.1"')
-  end
-  
-  after do
-    stop_server
-  end
-end

data/spec/server/threaded_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Server, 'with threads' do
-  before do
-    @requests = 0
-    start_server DEFAULT_TEST_ADDRESS, DEFAULT_TEST_PORT, :threaded => true do |env|
-      sleep env['PATH_INFO'].delete('/').to_i
-      @requests += 1
-      [200, { 'Content-Type' => 'text/html' }, 'hi']
-    end
-  end
-  
-  it "should process request" do
-    get('/').should_not be_empty
-  end
-  
-  it "should process requests when blocked" do
-    slow_request = Thread.new { get('/3') }
-    get('/').should_not be_empty
-    @requests.should == 1
-    slow_request.kill
-  end
-  
-  after do
-    stop_server
-  end
-end

data/spec/server/unix_socket_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Server, "on UNIX domain socket" do
-  before do
-    start_server('/tmp/thin_test.sock') do |env|
-      [200, { 'Content-Type' => 'text/html' }, [env.inspect]]
-    end
-  end
-  
-  it "should accept GET request" do
-    get("/?this").should include('this')
-  end
-  
-  it "should retreive remote address" do    
-    get('/').should include('"REMOTE_ADDR"=>"127.0.0.1"')
-  end
-  
-  it "should remove socket file after server stops" do
-    @server.stop!
-    File.exist?('/tmp/thin_test.sock').should be_false
-  end
-  
-  after do
-    stop_server
-  end
-end

data/spec/server_spec.rb

@@ -1,100 +0,0 @@
-require 'spec_helper'
-
-describe Server do
-  before do
-    @server = Server.new('0.0.0.0', 3000)
-  end
-  
-  it "should set maximum_connections size" do
-    @server.maximum_connections = 100
-    @server.config
-    @server.maximum_connections.should == 100
-  end
-
-  it "should set lower maximum_connections size when too large" do
-    # root users under Linux will not have a limitation on maximum
-    # connections, so we cannot really run this test under that
-    # condition.
-    pending("only for non-root users") if Process.euid == 0
-    @server.maximum_connections = 100_000
-    @server.config
-    @server.maximum_connections.should < 100_000
-  end
-  
-  it "should default to non-threaded" do
-    @server.should_not be_threaded
-  end
-  
-  it "should set backend to threaded" do
-    @server.threaded = true
-    @server.backend.should be_threaded
-  end
-end
-
-describe Server, "initialization" do
-  it "should set host and port" do
-    server = Server.new('192.168.1.1', 8080)
-
-    server.host.should == '192.168.1.1'
-    server.port.should == 8080
-  end
-
-  it "should set socket" do
-    server = Server.new('/tmp/thin.sock')
-
-    server.socket.should == '/tmp/thin.sock'
-  end
-  
-  it "should set host, port and app" do
-    app = proc {}
-    server = Server.new('192.168.1.1', 8080, app)
-    
-    server.host.should_not be_nil
-    server.app.should == app
-  end
-
-  it "should set socket and app" do
-    app = proc {}
-    server = Server.new('/tmp/thin.sock', app)
-    
-    server.socket.should_not be_nil
-    server.app.should == app
-  end
-
-  it "should set socket, nil and app" do
-    app = proc {}
-    server = Server.new('/tmp/thin.sock', nil, app)
-    
-    server.socket.should_not be_nil
-    server.app.should == app
-  end
-  
-  it "should set host, port and backend" do
-    server = Server.new('192.168.1.1', 8080, :backend => Thin::Backends::SwiftiplyClient)
-    
-    server.host.should_not be_nil
-    server.backend.should be_kind_of(Thin::Backends::SwiftiplyClient)
-  end  
-
-  it "should set host, port, app and backend" do
-    app = proc {}
-    server = Server.new('192.168.1.1', 8080, app, :backend => Thin::Backends::SwiftiplyClient)
-    
-    server.host.should_not be_nil
-    server.app.should == app
-    server.backend.should be_kind_of(Thin::Backends::SwiftiplyClient)
-  end
-  
-  it "should set port as string" do
-    app = proc {}
-    server = Server.new('192.168.1.1', '8080')
-    
-    server.host.should == '192.168.1.1'
-    server.port.should == 8080
-  end
-  
-  it "should not register signals w/ :signals => false" do
-    Server.should_not_receive(:setup_signals)
-    Server.new(:signals => false)
-  end
-end

data/spec/spec_helper.rb

@@ -1,234 +0,0 @@
-require 'rubygems'
-require 'thin'
-gem "rspec", "~> 1.2.9"
-require 'spec'
-require 'benchmark'
-require 'timeout'
-require 'fileutils'
-require 'net/http'
-require 'socket'
-
-include Thin
-
-FileUtils.mkdir_p File.dirname(__FILE__) + '/../log'
-Command.script = File.dirname(__FILE__) + '/../bin/thin'
-Logging.silent = true
-
-unless Object.const_defined?(:SWIFTIPLY_PATH)
-  SWIFTIPLY_PATH       = `which swiftiply`.chomp
-  DEFAULT_TEST_ADDRESS = '0.0.0.0'
-  DEFAULT_TEST_PORT    = 3333
-end
-
-module Matchers
-  class BeFasterThen
-    def initialize(max_time)
-      require 'benchmark_unit'
-      @max_time = max_time
-    end
-
-    # Base on benchmark_unit/assertions#compare_benchmarks
-    def matches?(proc)
-      @time, multiplier = 0, 1
-      
-      while (@time < 0.01) do
-        @time = Benchmark::Unit.measure do 
-          multiplier.times &proc
-        end
-        multiplier *= 10
-      end
-      
-      multiplier /= 10
-      
-      iterations = (Benchmark::Unit::CLOCK_TARGET / @time).to_i * multiplier
-      iterations = 1 if iterations < 1
-      
-      total = Benchmark::Unit.measure do 
-        iterations.times &proc
-      end
-      
-      @time = total / iterations
-      
-      @time < @max_time
-    end
-    
-    def failure_message(less_more=:less)
-      "took <#{@time.inspect} RubySeconds>, should take #{less_more} than #{@max_time} RubySeconds."
-    end
-
-    def negative_failure_message
-      failure_message :more
-    end
-  end
-  
-  class ValidateWithLint
-    def matches?(request)
-      @request = request
-      Rack::Lint.new(proc{[200, {'Content-Type' => 'text/html', 'Content-Length' => '0'}, []]}).call(@request.env)
-      true
-    rescue Rack::Lint::LintError => e
-      @message = e.message
-      false
-    end
-    
-    def failure_message(negation=nil)
-      "should#{negation} validate with Rack Lint: #{@message}"
-    end
-
-    def negative_failure_message
-      failure_message ' not'
-    end
-  end
-
-  class TakeLessThen
-    def initialize(time)
-      @time = time
-    end
-    
-    def matches?(proc)
-      Timeout.timeout(@time) { proc.call }
-      true
-    rescue Timeout::Error
-      false 
-    end
-    
-    def failure_message(negation=nil)
-      "should#{negation} take less then #{@time} sec to run"
-    end
-
-    def negative_failure_message
-      failure_message ' not'
-    end
-  end
-
-  # Actual matchers that are exposed.
-
-  def be_faster_then(time)
-    BeFasterThen.new(time)
-  end
-  
-  def validate_with_lint
-    ValidateWithLint.new
-  end
-
-  def take_less_then(time)
-    TakeLessThen.new(time)
-  end  
-end
-
-module Helpers
-  # 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_warnings
-    old_verbose, $VERBOSE = $VERBOSE, nil
-    yield
-  ensure
-    $VERBOSE = old_verbose
-  end
-  
-  # Create and parse a request
-  def R(raw, convert_line_feed=false)
-    raw.gsub!("\n", "\r\n") if convert_line_feed
-    request = Thin::Request.new
-    request.parse(raw)
-    request
-  end
-  
-  def start_server(address=DEFAULT_TEST_ADDRESS, port=DEFAULT_TEST_PORT, options={}, &app)
-    @server = Thin::Server.new(address, port, options, app)
-    @server.ssl = options[:ssl]
-    @server.threaded = options[:threaded]
-    @server.timeout = 3
-    
-    @thread = Thread.new { @server.start }
-    if options[:wait_for_socket]
-      wait_for_socket(address, port)
-    else
-      # If we can't ping the address fallback to just wait for the server to run
-      sleep 0.01 until @server.running?
-    end
-  end
-  
-  def stop_server
-    @server.stop!
-    @thread.kill
-    
-    100.times do
-      break unless EM.reactor_running?
-      sleep 0.01
-    end
-
-    raise "Reactor still running, wtf?" if EventMachine.reactor_running?
-  end
-  
-  def wait_for_socket(address=DEFAULT_TEST_ADDRESS, port=DEFAULT_TEST_PORT, timeout=5)
-    Timeout.timeout(timeout) do
-      loop do
-        begin
-          if address.include?('/')
-            UNIXSocket.new(address).close
-          else
-            TCPSocket.new(address, port).close
-          end
-          return true
-        rescue
-        end
-      end
-    end
-  end
-    
-  def send_data(data)
-    if @server.backend.class == Backends::UnixServer
-      socket = UNIXSocket.new(@server.socket)
-    else
-      socket = TCPSocket.new(@server.host, @server.port)
-    end
-    socket.write data
-    out = socket.read
-    socket.close
-    out
-  end
-  
-  def parse_response(response)
-    raw_headers, body = response.split("\r\n\r\n", 2)
-    raw_status, raw_headers = raw_headers.split("\r\n", 2)
-
-    status  = raw_status.match(%r{\AHTTP/1.1\s+(\d+)\b}).captures.first.to_i
-    headers = Hash[ *raw_headers.split("\r\n").map { |h| h.split(/:\s+/, 2) }.flatten ]
-
-    [ status, headers, body ]
-  end
-  
-  def get(url)
-    if @server.backend.class == Backends::UnixServer
-      send_data("GET #{url} HTTP/1.1\r\nConnection: close\r\n\r\n")
-    else
-      Net::HTTP.get(URI.parse("http://#{@server.host}:#{@server.port}" + url))
-    end
-  end
-  
-  def post(url, params={})
-    Net::HTTP.post_form(URI.parse("http://#{@server.host}:#{@server.port}" + url), params).body
-  end
-end
-
-Spec::Runner.configure do |config|
-  config.include Matchers
-  config.include Helpers
-end