thin 1.3.1 → 1.4.0

data/spec/controllers/controller_spec.rb

@@ -1,129 +0,0 @@
-require '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

@@ -1,50 +0,0 @@
-require 'spec_helper'
-include Controllers
-
-describe Service do
-  before(:all) do
-    silence_warnings 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

@@ -1,200 +0,0 @@
-require '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
-  
-    timeout(10) do
-      silence_stream STDOUT do
-        TestServer.kill(@server.pid_file, 1)
-      end
-    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
-  
-    timeout(10) do
-      silence_stream STDOUT do
-        TestServer.kill(@server.pid_file, 0)
-      end
-    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

@@ -1,40 +0,0 @@
-require '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

@@ -1,52 +0,0 @@
-require '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
-
-  it "should print errors to STDERR" do
-    error = mock(:error, :backtrace => Array("PC LOAD LETTER"))
-    STDERR.should_receive(:print).with(/PC LOAD LETTER/)
-    @object.log_error(error)
-  end
-  
-  after do
-    Logging.silent = true
-  end
-end