steamcannon-thin 1.2.8

data/spec/controllers/controller_spec.rb

@@ -0,0 +1,129 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'ostruct'
+include Controllers
+
+describe Controller, 'start' do
+  before do
+    @controller = Controller.new(:address              => '0.0.0.0',
+                                 :port                 => 3000,
+                                 :pid                  => 'thin.pid',
+                                 :log                  => 'thin.log',
+                                 :timeout              => 60,
+                                 :max_conns            => 2000,
+                                 :max_persistent_conns => 1000,
+                                 :adapter              => 'rails')
+    
+    @server = OpenStruct.new
+    @adapter = OpenStruct.new
+    
+    Server.should_receive(:new).with('0.0.0.0', 3000, @controller.options).and_return(@server)
+    @server.should_receive(:config)
+    Rack::Adapter::Rails.stub!(:new).and_return(@adapter)
+  end
+  
+  it "should configure server" do
+    @controller.start
+    
+    @server.app.should == @adapter
+    @server.pid_file.should == 'thin.pid'
+    @server.log_file.should == 'thin.log'
+    @server.maximum_connections.should == 2000
+    @server.maximum_persistent_connections.should == 1000
+  end
+  
+  it "should start as daemon" do
+    @controller.options[:daemonize] = true
+    @controller.options[:user] = true
+    @controller.options[:group] = true
+    
+    @server.should_receive(:daemonize)
+    @server.should_receive(:change_privilege)
+
+    @controller.start
+  end
+  
+  it "should configure Rails adapter" do
+    Rack::Adapter::Rails.should_receive(:new).with(@controller.options.merge(:root => nil))
+    
+    @controller.start
+  end
+  
+  it "should mount app under :prefix" do
+    @controller.options[:prefix] = '/app'
+    @controller.start
+    
+    @server.app.class.should == Rack::URLMap
+  end
+
+  it "should mount Stats adapter under :stats" do
+    @controller.options[:stats] = '/stats'
+    @controller.start
+    
+    @server.app.class.should == Stats::Adapter
+  end
+  
+  it "should load app from Rack config" do
+    @controller.options[:rackup] = File.dirname(__FILE__) + '/../../example/config.ru'
+    @controller.start
+    
+    @server.app.class.should == Proc
+  end
+
+  it "should load app from ruby file" do
+    @controller.options[:rackup] = File.dirname(__FILE__) + '/../../example/myapp.rb'
+    @controller.start
+    
+    @server.app.should == Myapp
+  end
+
+  it "should throwup if rackup is not a .ru or .rb file" do
+    proc do
+      @controller.options[:rackup] = File.dirname(__FILE__) + '/../../example/myapp.foo'
+      @controller.start
+    end.should raise_error(RuntimeError, /please/)
+  end
+  
+  it "should set server as threaded" do
+    @controller.options[:threaded] = true
+    @controller.start
+    
+    @server.threaded.should be_true
+  end
+  
+  it "should set RACK_ENV" do
+    @controller.options[:rackup] = File.dirname(__FILE__) + '/../../example/config.ru'
+    @controller.options[:environment] = "lolcat"
+    @controller.start
+    
+    ENV['RACK_ENV'].should == "lolcat"
+  end
+    
+end
+
+describe Controller do
+  before do
+    @controller = Controller.new(:pid => 'thin.pid', :timeout => 10)
+    @controller.stub!(:wait_for_file)
+  end
+  
+  it "should stop" do
+    Server.should_receive(:kill).with('thin.pid', 10)
+    @controller.stop
+  end
+  
+  it "should restart" do
+    Server.should_receive(:restart).with('thin.pid')
+    @controller.restart
+  end
+  
+  it "should write configuration file" do
+    silence_stream(STDOUT) do
+      Controller.new(:config => 'test.yml', :port => 5000, :address => '127.0.0.1').config
+    end
+
+    File.read('test.yml').should include('port: 5000', 'address: 127.0.0.1')
+    File.read('test.yml').should_not include('config: ')
+
+    File.delete('test.yml')
+  end
+end

data/spec/controllers/service_spec.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+include Controllers
+
+describe Service do
+  before(:all) do
+    silence_stream(STDERR) do
+      Service::INITD_PATH          = 'tmp/sandbox' + Service::INITD_PATH
+      Service::DEFAULT_CONFIG_PATH = 'tmp/sandbox' + Service::DEFAULT_CONFIG_PATH
+    end
+  end
+  
+  before do
+    Thin.stub!(:linux?).and_return(true)
+    FileUtils.mkdir_p 'tmp/sandbox'
+        
+    @service = Service.new(:all => 'spec/configs')
+  end
+  
+  it "should call command for each config file" do
+    Command.should_receive(:run).with(:start, :config => 'spec/configs/cluster.yml', :daemonize => true)
+    Command.should_receive(:run).with(:start, :config => 'spec/configs/single.yml', :daemonize => true)
+    
+    @service.start
+  end
+  
+  it "should create /etc/init.d/thin file when calling install" do
+    @service.install
+    
+    File.exist?(Service::INITD_PATH).should be_true
+    File.read(Service::INITD_PATH).should include('CONFIG_PATH=tmp/sandbox/etc/thin',
+                                                  'SCRIPT_NAME=tmp/sandbox/etc/init.d/thin',
+                                                  'DAEMON=' + Command.script)
+  end
+  
+  it "should create /etc/thin dir when calling install" do
+    @service.install
+    
+    File.directory?(Service::DEFAULT_CONFIG_PATH).should be_true
+  end
+  
+  it "should include specified path in /etc/init.d/thin script" do
+    @service.install('tmp/sandbox/usr/thin')
+    
+    File.read(Service::INITD_PATH).should include('CONFIG_PATH=tmp/sandbox/usr/thin')
+  end
+  
+  after do
+    FileUtils.rm_rf 'tmp/sandbox'
+  end
+end

data/spec/daemonizing_spec.rb

@@ -0,0 +1,196 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class TestServer
+  include Logging # Daemonizable should include this?
+  include Daemonizable
+  
+  def stop
+  end
+  
+  def name
+    'Thin test server'
+  end
+end
+
+describe 'Daemonizing' do
+  before :all do
+    @logfile = File.dirname(__FILE__) + '/../log/daemonizing_test.log'
+    @pidfile = 'test.pid'
+    File.delete(@logfile) if File.exist?(@logfile)
+    File.delete(@pidfile) if File.exist?(@pidfile)
+  end
+  
+  before :each do
+    @server = TestServer.new
+    @server.log_file = @logfile
+    @server.pid_file = @pidfile
+    @pid = nil
+  end
+  
+  it 'should have a pid file' do
+    @server.should respond_to(:pid_file)
+    @server.should respond_to(:pid_file=)
+  end
+  
+  it 'should create a pid file' do
+    @pid = fork do
+      @server.daemonize
+      sleep 1
+    end
+    
+    sleep 1
+    Process.wait(@pid)
+    File.exist?(@server.pid_file).should be_true
+    @pid = @server.pid
+
+    proc { sleep 0.1 while File.exist?(@server.pid_file) }.should take_less_then(5)
+  end
+  
+  it 'should redirect stdio to a log file' do
+    @pid = fork do
+      @server.log_file = 'daemon_test.log'
+      @server.daemonize
+
+      puts "simple puts"
+      STDERR.puts "STDERR.puts"
+      STDOUT.puts "STDOUT.puts"
+    end
+    Process.wait(@pid)
+    # Wait for the file to close and magical stuff to happen
+    proc { sleep 0.1 until File.exist?('daemon_test.log') }.should take_less_then(3)
+    sleep 0.5
+    
+    @pid = @server.pid
+
+    log = File.read('daemon_test.log')
+    log.should include('simple puts', 'STDERR.puts', 'STDOUT.puts')
+    
+    File.delete 'daemon_test.log'
+  end
+  
+  it 'should change privilege' do
+    @pid = fork do
+      @server.daemonize
+      @server.change_privilege('root', 'admin')
+    end
+    Process.wait(@pid)
+    $?.should be_a_success
+  end
+  
+  it 'should kill process in pid file' do
+    @pid = fork do
+      @server.daemonize
+      loop { sleep 3 }
+    end
+  
+    server_should_start_in_less_then 3
+    
+    @pid = @server.pid
+  
+    silence_stream STDOUT do
+      TestServer.kill(@server.pid_file, 1)
+    end
+  
+    File.exist?(@server.pid_file).should be_false
+  end
+  
+  it 'should force kill process in pid file' do
+    @pid = fork do
+      @server.daemonize
+      loop { sleep 3 }
+    end
+  
+    server_should_start_in_less_then 3
+    
+    @pid = @server.pid
+  
+    silence_stream STDOUT do
+      TestServer.kill(@server.pid_file, 0)
+    end
+  
+    File.exist?(@server.pid_file).should be_false
+  end
+  
+  it 'should send kill signal if timeout' do
+    @pid = fork do
+      @server.should_receive(:stop) # pretend we cannot handle the INT signal
+      @server.daemonize
+      sleep 5
+    end
+  
+    server_should_start_in_less_then 10
+    
+    @pid = @server.pid
+  
+    silence_stream STDOUT do
+      TestServer.kill(@server.pid_file, 1)
+    end
+    
+    sleep 1
+  
+    File.exist?(@server.pid_file).should be_false
+    Process.running?(@pid).should be_false
+  end
+  
+  it "should restart" do
+    @pid = fork do
+      @server.on_restart {}
+      @server.daemonize
+      sleep 5
+    end
+    
+    server_should_start_in_less_then 10
+    
+    @pid = @server.pid
+  
+    silence_stream STDOUT do
+      TestServer.restart(@server.pid_file)
+    end
+    
+    proc { sleep 0.1 while File.exist?(@server.pid_file) }.should take_less_then(10)
+  end
+  
+  it "should ignore if no restart block specified" do
+    TestServer.restart(@server.pid_file)
+  end
+  
+  it "should not restart when not running" do
+    silence_stream STDOUT do
+      TestServer.restart(@server.pid_file)
+    end
+  end
+  
+  it "should exit and raise if pid file already exist" do
+    @pid = fork do
+      @server.daemonize
+      sleep 5
+    end
+    server_should_start_in_less_then 10
+    
+    @pid = @server.pid
+
+    proc { @server.daemonize }.should raise_error(PidFileExist)
+    
+    File.exist?(@server.pid_file).should be_true
+  end
+  
+  it "should should delete pid file if stale" do
+    # Create a file w/ a PID that does not exist
+    File.open(@server.pid_file, 'w') { |f| f << 999999999 }
+    
+    @server.send(:remove_stale_pid_file)
+    
+    File.exist?(@server.pid_file).should be_false
+  end
+  
+  after do
+    Process.kill(9, @pid.to_i) if @pid && Process.running?(@pid.to_i)
+    Process.kill(9, @server.pid) if @server.pid && Process.running?(@server.pid)
+    File.delete(@server.pid_file) rescue nil
+  end
+  
+  private
+    def server_should_start_in_less_then(sec=10)
+      proc { sleep 0.1 until File.exist?(@server.pid_file) }.should take_less_then(10)
+    end
+end

data/spec/headers_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Headers do
+  before do
+    @headers = Headers.new
+  end
+  
+  it 'should allow duplicate on some fields' do
+    @headers['Set-Cookie'] = 'twice'
+    @headers['Set-Cookie'] = 'is cooler the once'
+    
+    @headers.to_s.should == "Set-Cookie: twice\r\nSet-Cookie: is cooler the once\r\n"
+  end
+  
+  it 'should overwrite value on non duplicate fields' do
+    @headers['Host'] = 'this is unique'
+    @headers['Host'] = 'so is this'
+
+    @headers.to_s.should == "Host: this is unique\r\n"
+  end
+  
+  it 'should output to string' do
+    @headers['Host'] = 'localhost:3000'
+    @headers['Set-Cookie'] = 'twice'
+    @headers['Set-Cookie'] = 'is cooler the once'
+    
+    @headers.to_s.should == "Host: localhost:3000\r\nSet-Cookie: twice\r\nSet-Cookie: is cooler the once\r\n"
+  end
+
+  it 'should ignore nil values' do
+    @headers['Something'] = nil
+    @headers.to_s.should_not include('Something: ')
+  end
+
+  it 'should format Time values correctly' do
+    time = Time.now
+    @headers['Modified-At'] = time
+    @headers.to_s.should include("Modified-At: #{time.httpdate}")
+  end
+end

data/spec/logging_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class TestLogging
+  include Logging
+end
+
+describe Logging do
+  before do
+    Logging.silent = false
+    @object = TestLogging.new
+  end
+  
+  it "should output debug when set to true" do
+    Logging.debug = true
+    @object.should_receive(:puts)
+    @object.debug 'hi'
+  end
+
+  it "should output trace when set to true" do
+    Logging.trace = true
+    @object.should_receive(:puts)
+    @object.trace 'hi'
+  end
+
+  it "should not output when silenced" do
+    Logging.silent = true
+    @object.should_not_receive(:puts)
+    @object.log 'hi'
+  end
+  
+  it "should not output when silenced as instance method" do
+    @object.silent = true
+    
+    @object.should_not_receive(:puts)
+    @object.log 'hi'
+  end
+  
+  it "should be usable as module functions" do
+    Logging.silent = true
+    Logging.log "hi"
+  end
+  
+  after do
+    Logging.silent = true
+  end
+end