grockit-thin 0.8.2

data/spec/runner_spec.rb

@@ -0,0 +1,167 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Runner do
+  it "should parse options" do
+    runner = Runner.new(%w(start --pid test.pid --port 5000))
+    
+    runner.options[:pid].should == 'test.pid'
+    runner.options[:port].should == 5000
+  end
+  
+  it "should parse specified command" do
+    Runner.new(%w(start)).command.should == 'start'
+    Runner.new(%w(stop)).command.should == 'stop'
+    Runner.new(%w(restart)).command.should == 'restart'
+  end
+  
+  it "should abort on unknow command" do
+    runner = Runner.new(%w(poop))
+    
+    runner.should_receive(:abort)
+    runner.run!
+  end
+  
+  it "should exit on empty command" do
+    runner = Runner.new([])
+    
+    runner.should_receive(:exit).with(1)
+    
+    silence_stream(STDOUT) do
+      runner.run!
+    end
+  end
+  
+  it "should use Controller when controlling a single server" do
+    runner = Runner.new(%w(start))
+    
+    controller = mock('controller')
+    controller.should_receive(:start)
+    Controllers::Controller.should_receive(:new).and_return(controller)
+    
+    runner.run!
+  end
+
+  it "should use Cluster controller when controlling multiple servers" do
+    runner = Runner.new(%w(start --servers 3))
+    
+    controller = mock('cluster')
+    controller.should_receive(:start)
+    Controllers::Cluster.should_receive(:new).and_return(controller)
+    
+    runner.run!
+  end
+  
+  it "should default to single server controller" do
+    Runner.new(%w(start)).should_not be_a_cluster
+  end
+  
+  it "should consider as a cluster with :servers option" do
+    Runner.new(%w(start --servers 3)).should be_a_cluster
+  end
+  
+  it "should consider as a cluster with :only option" do
+    Runner.new(%w(start --only 3000)).should be_a_cluster
+  end
+  
+  it "should warn when require a rack config file" do
+    STDERR.stub!(:write)
+    STDERR.should_receive(:write).with(/WARNING:/)
+    
+    runner = Runner.new(%w(start -r config.ru))
+    runner.run! rescue nil
+    
+    runner.options[:rackup].should == 'config.ru'
+  end
+  
+  it "should require file" do
+    runner = Runner.new(%w(start -r unexisting))
+    proc { runner.run! }.should raise_error(LoadError)
+  end
+  
+  it "should remember requires" do
+    runner = Runner.new(%w(start -r rubygems -r thin))
+    runner.options[:require].should == %w(rubygems thin)
+  end
+
+  it "should remember debug options" do
+    runner = Runner.new(%w(start -D -V))
+    runner.options[:debug].should be_true
+    runner.options[:trace].should be_true
+  end
+
+  it "should default debug and trace to false" do
+    runner = Runner.new(%w(start))
+    runner.options[:debug].should_not be_true
+    runner.options[:trace].should_not be_true
+  end
+end
+
+describe Runner, 'with config file' do
+  before do
+    @runner = Runner.new(%w(start --config spec/configs/cluster.yml))
+  end
+  
+  it "should load options from file with :config option" do
+    @runner.send :load_options_from_config_file!
+    
+    @runner.options[:environment].should == 'production'
+    @runner.options[:chdir].should == 'spec/rails_app'
+    @runner.options[:port].should == 5000
+    @runner.options[:servers].should == 3
+  end
+  
+  it "should change directory after loading config" do
+    @orig_dir = Dir.pwd
+    
+    controller = mock('controller')
+    controller.should_receive(:respond_to?).with('start').and_return(true)
+    controller.should_receive(:start)
+    Controllers::Cluster.should_receive(:new).and_return(controller)
+    expected_dir = File.expand_path('spec/rails_app')
+    
+    begin
+      silence_stream(STDERR) do
+        @runner.run!
+      end
+  
+      Dir.pwd.should == expected_dir
+    
+    ensure
+      # any other spec using relative paths should work as expected
+      Dir.chdir(@orig_dir)
+    end
+  end
+end
+
+describe Runner, "service" do
+  before do
+    Thin.stub!(:linux?).and_return(true)
+    
+    @controller = mock('service')
+    Controllers::Service.stub!(:new).and_return(@controller)
+  end
+  
+  it "should use Service controller when controlling all servers" do
+    runner = Runner.new(%w(start --all))
+    
+    @controller.should_receive(:start)
+    
+    runner.run!
+  end
+  
+  it "should call install with arguments" do
+    runner = Runner.new(%w(install /etc/cool))
+    
+    @controller.should_receive(:install).with('/etc/cool')
+    
+    runner.run!
+  end
+
+  it "should call install without arguments" do
+    runner = Runner.new(%w(install))
+    
+    @controller.should_receive(:install).with()
+    
+    runner.run!
+  end  
+end

data/spec/server/builder_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Server, 'app builder' do
+  it "should build app from constructor" do
+    app = proc {}
+    server = Server.new('0.0.0.0', 3000, app)
+    
+    server.app.should == app
+  end
+  
+  it "should build app from builder block" do
+    server = Server.new '0.0.0.0', 3000 do
+      run(proc { |env| :works })
+    end
+    
+    server.app.call({}).should == :works
+  end
+  
+  it "should use middlewares in builder block" do
+    server = Server.new '0.0.0.0', 3000 do
+      use Rack::ShowExceptions
+      run(proc { |env| :works })
+    end
+    
+    server.app.class.should == Rack::ShowExceptions
+    server.app.call({}).should == :works
+  end
+  
+  it "should work with Rack url mapper" do
+    server = Server.new '0.0.0.0', 3000 do
+      map '/test' do
+        run(proc { |env| [200, {}, 'Found /test'] })
+      end
+    end
+    
+    default_env = { 'SCRIPT_NAME' => '' }
+    
+    server.app.call(default_env.update('PATH_INFO' => '/'))[0].should == 404
+    
+    status, headers, body = server.app.call(default_env.update('PATH_INFO' => '/test'))
+    status.should == 200
+    body.should == 'Found /test'
+  end
+end

data/spec/server/pipelining_spec.rb

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Server, "HTTP pipelining" do
+  before do
+    calls = 0
+    start_server do |env|
+      calls += 1
+      body = env['PATH_INFO'] + '-' + calls.to_s
+      [200, { 'Content-Type' => 'text/html' }, body]
+    end
+    @server.maximum_persistent_connections = 1024
+  end
+  
+  it "should pipeline request on same socket" do
+    socket = TCPSocket.new('0.0.0.0', 3333)
+    socket.write "GET /first HTTP/1.1\r\nConnection: keep-alive\r\n\r\n"
+    socket.flush
+    socket.write "GET /second HTTP/1.1\r\nConnection: close\r\n\r\n"
+    response = socket.read
+    socket.close
+    
+    wait_for_requests_to_complete!
+    
+    response.should include('/first-1', '/second-2')
+  end
+  
+  it "should pipeline requests by default on HTTP 1.1" do
+    socket = TCPSocket.new('0.0.0.0', 3333)
+    socket.write "GET /first HTTP/1.1\r\n\r\n"
+    socket.flush
+    socket.write "GET /second HTTP/1.1\r\nConnection: close\r\n\r\n"
+    socket.flush
+    response = socket.read
+    socket.close
+    
+    wait_for_requests_to_complete!
+    
+    response.should include('/first-1', '/second-2')
+  end
+  
+  it "should not pipeline request by default on HTTP 1.0" do
+    socket = TCPSocket.new('0.0.0.0', 3333)
+    socket.write "GET /first HTTP/1.0\r\n\r\n"
+    socket.flush
+    socket.write "GET /second HTTP/1.0\r\nConnection: close\r\n\r\n"
+    response = socket.read
+    socket.close
+    
+    wait_for_requests_to_complete!
+    
+    response.should include('/first-1')
+    response.should_not include('/second-2')
+  end
+  
+  it "should not pipeline request on same socket when connection is closed" do
+    socket = TCPSocket.new('0.0.0.0', 3333)
+    socket.write "GET /first HTTP/1.1\r\nConnection: close\r\n\r\n"
+    socket.flush
+    socket.write "GET /second HTTP/1.1\r\nConnection: close\r\n\r\n"
+    response = socket.read
+    socket.close
+    
+    wait_for_requests_to_complete!
+    
+    response.should include('/first-1')
+    response.should_not include('/second-2')
+  end
+  
+  it "should not allow more persistent connection then maximum" do
+    @server.maximum_persistent_connections = 1
+    
+    socket1 = TCPSocket.new('0.0.0.0', 3333)
+    socket1.write "GET / HTTP/1.1\r\n\r\n"
+    socket1.flush
+    socket2 = TCPSocket.new('0.0.0.0', 3333)    
+    socket2.write "GET / HTTP/1.1\r\n\r\n"
+    socket2.flush
+    
+    @server.backend.persistent_connection_count.should == 1
+    @server.backend.size.should == 2
+    
+    socket1.close    
+    socket2.close
+  end
+  
+  it "should decrement persistent connection on close" do
+    socket = TCPSocket.new('0.0.0.0', 3333)
+    socket.write "GET / HTTP/1.1\r\n\r\n"
+    socket.flush
+    
+    @server.backend.persistent_connection_count.should == 1
+    
+    socket.write "GET / HTTP/1.1\r\nConnection: close\r\n\r\n"
+    socket.close
+    
+    wait_for_requests_to_complete!
+    
+    @server.backend.persistent_connection_count.should == 0
+  end
+  
+  after do
+    stop_server
+  end
+  
+  private
+    def wait_for_requests_to_complete!
+      sleep 0.1 until @server.backend.size == 0
+    end
+end

data/spec/server/robustness_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Server, 'robustness' do
+  before do
+    start_server do |env|
+      body = 'hello!'
+      [200, { 'Content-Type' => 'text/html' }, body]
+    end
+  end
+  
+  it "should not crash when header too large" do
+    100.times do
+      begin
+        socket = TCPSocket.new(DEFAULT_TEST_ADDRESS, DEFAULT_TEST_PORT)
+        socket.write("GET / HTTP/1.1\r\n")
+        socket.write("Host: localhost\r\n")
+        socket.write("Connection: close\r\n")
+        10000.times do
+        	socket.write("X-Foo: #{'x' * 100}\r\n")
+        	socket.flush
+        end
+        socket.write("\r\n")
+        socket.read
+        socket.close
+      rescue Errno::EPIPE, Errno::ECONNRESET
+				# Ignore.
+			end
+    end
+  end
+  
+  after do
+    stop_server
+  end
+end

data/spec/server/stopping_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Server, "stopping" do
+  before do
+    start_server do |env|
+      [200, { 'Content-Type' => 'text/html' }, ['ok']]
+    end
+  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")
+    @server.stop # Stop the server in the middle of a request
+    socket.write("\r\n\r\n")
+    
+    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 { socket.should be_closed }
+  end
+  
+  after do
+    stop_server
+  end
+end

data/spec/server/swiftiply.yml

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/../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

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + '/../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 add the Content-Length to the response when not present" do
+    status, headers, body = parse_response(send_data("GET / HTTP/1.0\r\nConnection: close\r\n\r\n"))
+    headers.should have_key('Content-Length')
+  end
+  
+  it 'should set the Content-Length to equal the body size in bytes' do
+    status, headers, body = parse_response(send_data("GET / HTTP/1.0\r\nConnection: close\r\n\r\n"))
+    headers['Content-Length'].should == (body.respond_to?(:bytesize) ? body.bytesize : body.size).to_s
+  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