rest-assured 0.3.2 → 1.0.0.rc1

data/rest-assured.gemspec

@@ -21,8 +21,9 @@ Gem::Specification.new do |s|
   s.require_paths         = ['lib']
 
   s.add_dependency 'sinatra', '>= 1.3.1'
-  s.add_dependency 'rack-flash', '>= 0.1.2'
   s.add_dependency 'rack', '<= 1.3.6'
+  s.add_dependency 'childprocess', '~> 0.2.8'
+  s.add_dependency 'sinatra-flash'
   s.add_dependency 'haml', '>= 3.1.3'
   s.add_dependency 'activerecord', '~> 3.1.0'
   s.add_dependency 'activeresource', '~> 3.1.0'

data/spec/api/app_runner_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../../../lib/rest-assured/api/app_runner', __FILE__)
+
+module RestAssured
+  describe AppRunner do
+    before do
+      Application.stub(:run!)
+      Config.stub(:included)
+    end
+
+    it 'requires Application' do
+      Kernel.should_receive(:require).with('rest-assured/application').and_return(true)
+      AppRunner.run!
+    end
+    it 'reloads config if Application has already been loaded' do
+      Kernel.stub(:require).and_return(false)
+
+      Application.should_receive(:send).with(:include, Config)
+      AppRunner.run!
+    end
+    it 'runs Application' do
+      Application.should_receive(:run!)
+      AppRunner.run!
+    end
+  end
+end
+

data/spec/api/app_session_spec.rb

@@ -0,0 +1,51 @@
+require 'childprocess'
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../../../lib/rest-assured/api/app_session', __FILE__)
+
+module RestAssured
+  describe AppSession do
+    context 'either without spork or outside prefork block' do
+      before do
+        AppSession.any_instance.stub(:running_in_drb? => false)
+      end
+
+      it 'start application in subprocess' do
+        state = ''
+        Utils::Subprocess.should_receive(:new) do |&block|
+          state << 'called from block'
+          block.call
+          state = ''
+        end
+        AppRunner.should_receive(:run!) do
+          state.should == 'called from block'
+        end
+
+        AppSession.new
+      end
+    end
+
+    context 'within spork prefork block' do
+      before do
+        AppSession.any_instance.stub(:running_in_drb? => true)
+      end
+
+      it 'starts application in childprocess' do
+        cmdargs = %w{-d :memory: -p 6666}
+        Config.stub(:to_cmdargs => cmdargs)
+
+        ChildProcess.should_receive(:build).with('rest-assured', *cmdargs).and_return(child = mock(:io => mock))
+
+        state = ''
+        child.io.should_receive(:inherit!) do
+          state.should_not == 'started'
+        end
+        child.should_receive(:start) do
+          state << 'started'
+        end
+
+        AppSession.new
+      end
+
+    end
+  end
+end

data/spec/{client → api}/resource_double_spec.rb

@@ -2,22 +2,9 @@ require 'uri'
 require File.expand_path('../../spec_helper', __FILE__)
 
 module RestAssured
-  describe Double do
-    before do
-      @orig_addr = RestAssured::Client.config.server_address
-    end
-
-    after do
-      RestAssured::Client.config.server_address = @orig_addr
-    end
-
+  describe Double, 'ruby-api' => true do
     it { should be_kind_of ActiveResource::Base }
 
-    it 'knows where rest-assured server is' do
-      RestAssured::Client.config.server_address = 'http://localhost:1234'
-      Double.site.should == URI.parse('http://localhost:1234')
-    end
-
     it 'creates new double' do
       d = Double.create :fullpath => '/some/api', :content => 'content'
       Models::Double.where(:fullpath => d.fullpath, :content => d.content).should exist

data/spec/api/server_spec.rb

@@ -0,0 +1,138 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require File.expand_path('../../../lib/rest-assured/api/server', __FILE__)
+
+module RestAssured
+  describe Server do
+    after do
+      Server.reset_instance
+    end
+
+    it 'khows when it is up' do
+      AppSession.stub(:new).and_return(session = stub(:alive? => true).as_null_object)
+      Utils::PortExplorer.stub(:port_free? => false)
+      Server.start
+
+      Server.up?.should == true
+    end
+
+    context 'knows that it is NOT up' do
+      it 'if it has not been started' do
+        Server.up?.should == false
+      end
+
+      it 'if it is starting at the moment' do
+        AppSession.stub(:new).and_return(session = stub(:alive? => true).as_null_object)
+        Utils::PortExplorer.stub(:port_free? => true)
+        Server.start!
+
+        Server.up?.should == false
+      end
+    end
+
+    context 'when starts' do
+      it 'makes sure no previous session is running' do
+        session = mock.as_null_object
+        session.stub(:alive?).and_return(true, false)
+        Utils::PortExplorer.stub(:port_free? => false)
+        AppSession.stub(:new).and_return(session)
+
+        session.should_receive(:stop).once
+        Server.start!
+        Server.start!
+      end
+
+      it 'builds application config' do
+        AppSession.stub(:new).as_null_object
+
+        opts = { :port => 34545, :database => ':memory:' }
+
+        Config.should_receive(:build).with(opts)
+        Server.start!(opts)
+      end
+
+      context 'sets up server address' do
+        before do
+          AppSession.stub(:new).as_null_object
+        end
+
+        it 'uses 127.0.0.1 as hostname' do
+          RestAssured::Double.should_receive(:site=).with(/127\.0\.0\.1/)
+          Server.start!
+          Server.address.should =~ /127\.0\.0\.1/
+        end
+
+        it 'uses port from config' do
+          RestAssured::Double.should_receive(:site=).with(/#{AppConfig.port}/)
+            Server.start!
+          Server.address.should =~ /#{AppConfig.port}/
+        end
+
+        it 'uses http by default' do
+          RestAssured::Double.should_receive(:site=).with(/http[^s]/)
+          Server.start!
+          Server.address.should =~ /http[^s]/
+        end
+
+        it 'uses https if ssl is set in config' do
+          AppConfig.ssl = true
+          RestAssured::Double.should_receive(:site=).with(/https/)
+          Server.start!
+          Server.address.should =~ /https/
+        end
+      end
+
+      describe 'async/sync start' do
+        before do
+          AppSession.stub(:new).and_return(session = stub(:alive? => false).as_null_object)
+          Utils::PortExplorer.stub(:port_free? => true)
+
+          @t = Thread.new do
+            sleep 0.5
+            session.stub(:alive?).and_return(true)
+            Utils::PortExplorer.stub(:port_free? => false)
+          end
+        end
+
+        after do
+          @t.join
+        end
+
+        it 'does not wait for Application to come up' do
+          Server.start!
+          Server.up?.should == false
+        end
+
+        it 'can wait until Application is up before passing control' do
+          Server.start
+          Server.up?.should == true
+        end
+      end
+    end
+
+    context 'when stopped' do
+      it 'stops application subprocess' do
+        AppSession.stub(:new).and_return(session = stub(:alive? => false))
+        Server.start!
+
+        session.should_receive(:stop)
+        Server.stop
+      end
+    end
+
+    it 'stops application subprocess when current process exits' do
+      if not running_in_drb? # drb breaks fork sandbox: at_exits a collected and fired all together on master process exit
+        res_file = Tempfile.new('res')
+        AppSession.stub(:new).and_return(session = mock.as_null_object)
+        session.stub(:stop) do
+          res_file.write "stopped"
+          res_file.rewind
+        end
+        fork do
+          Server.start!
+        end
+        Process.wait
+        res_file.read.should == 'stopped'
+      end
+    end
+  end
+end

data/spec/config_spec.rb

@@ -2,131 +2,149 @@ require File.expand_path('../../lib/rest-assured/config', __FILE__)
 require 'rack'
 require 'openssl'
 require 'webrick'
+require 'enumerator'
 
-describe RestAssured::Config do
-  #this is thoroughly covered in cucumber (since there it also serves documentation purposes)
-  #it 'builds config from user options'
-
-  it 'initializes logger' do
-    logger = double(:logger).as_null_object
-    AppConfig.stub(:logfile).and_return('test.log')
-
-    Logger.should_receive(:new).with('test.log').and_return(logger)
-
-    RestAssured::Config.init_logger
-  end
+module RestAssured
+  describe Config do
+    before do
+      Config.build
+    end
 
-  context 'db setup' do
-    it 'connects db' do
-      RestAssured::Config.stub(:migrate_db) # so it does not complain
-      AppConfig.stub(:db_config).and_return('db_config')
+    context 'builds config from user options' do
+      #this is thoroughly covered in cucumber (since there it also serves documentation purposes)
+    end
 
-      ActiveRecord::Base.should_receive(:establish_connection).with('db_config')
+    context 'when included in Application' do
+      let(:app) { mock(:app).as_null_object }
 
-      RestAssured::Config.setup_db
-    end
+      it 'initializes logger' do
+        Config.stub(:setup_db)
+        logger = double(:logger).as_null_object
+        AppConfig.stub(:logfile).and_return('test.log')
 
-    context 'active_record logging' do
-      let(:logger) { double(:logger).as_null_object }
+        Logger.should_receive(:new).with('test.log').and_return(logger)
 
-      before do
-        RestAssured::Config.stub(:migrate_db)
-        RestAssured::Config.stub(:connect_db)
+        Config.included(app)
       end
 
-      it 'is silenced in production' do
-        AppConfig.stub(:environment).and_return('production')
-        Logger.should_receive(:new).with(RestAssured::Config.dev_null).and_return(logger)
+      context 'db setup' do
+        it 'connects db' do
+          Config.stub(:init_logger)
+          Config.stub(:migrate_db) # so it does not complain
+          AppConfig.stub(:db_config).and_return('db_config')
 
-        ActiveRecord::Base.should_receive(:logger=).with(logger)
+          ActiveRecord::Base.should_receive(:establish_connection).with('db_config')
 
-        RestAssured::Config.setup_db
-      end
+          Config.included(app)
+        end
 
-      it 'is set to app logger for non production' do
-        AppConfig.stub(:environment).and_return('test')
-        AppConfig.stub(:logger).and_return(logger)
+        context 'active_record logging' do
+          let(:logger) { double(:logger).as_null_object }
 
-        ActiveRecord::Base.should_receive(:logger=).with(logger)
+          before do
+            Config.stub(:migrate_db)
+            Config.stub(:connect_db)
+          end
 
-        RestAssured::Config.setup_db
-      end
-    end
+          it 'is silenced in production' do
+            AppConfig.stub(:environment).and_return('production')
+            Logger.should_receive(:new).with(Config.dev_null).and_return(logger)
 
-    it 'runs migrations' do
-      RestAssured::Config.stub(:connect_db) # so it does not complain
+            ActiveRecord::Base.should_receive(:logger=).with(logger)
 
-      ActiveRecord::Migrator.should_receive(:migrate)
+            Config.setup_db
+          end
 
-      RestAssured::Config.setup_db
-    end
-  end
+          it 'is set to app logger for non production' do
+            AppConfig.stub(:environment).and_return('test')
+            AppConfig.stub(:logger).and_return(logger)
 
-  context 'when included in RestAssured::Application' do
-    let(:app) { mock(:app).as_null_object }
+            ActiveRecord::Base.should_receive(:logger=).with(logger)
 
-    before do
-      RestAssured::Config.build
-    end
+            Config.setup_db
+          end
+        end
 
-    it 'initializes resources' do
-      RestAssured::Config.should_receive(:init_logger)
-      RestAssured::Config.should_receive(:setup_db)
+        it 'runs migrations' do
+          Config.stub(:connect_db) # so it does not complain
 
-      RestAssured::Config.included(app)
-    end
+          ActiveRecord::Migrator.should_receive(:migrate)
 
-    it 'sets up environment' do
-      app.should_receive(:set).with(:environment, AppConfig.environment)
-      RestAssured::Config.included(app)
-    end
+          Config.setup_db
+        end
+      end
 
-    it 'sets up port' do
-      app.should_receive(:set).with(:port, AppConfig.port)
-      RestAssured::Config.included(app)
-    end
+      it 'sets up environment' do
+        app.should_receive(:set).with(:environment, AppConfig.environment)
+        Config.included(app)
+      end
 
-    it 'connects logger' do
-      logger = double(:logger).as_null_object
-      AppConfig.stub(:logger).and_return(logger)
+      it 'sets up port' do
+        app.should_receive(:set).with(:port, AppConfig.port)
+        Config.included(app)
+      end
 
-      app.should_receive(:enable).with(:logging)
-      app.should_receive(:use).with(Rack::CommonLogger, logger)
+      it 'connects logger to application' do
+        logger = double(:logger).as_null_object
+        AppConfig.stub(:logger).and_return(logger)
 
-      RestAssured::Config.included(app)
-    end
+        app.should_receive(:enable).with(:logging)
+        app.should_receive(:use).with(Rack::CommonLogger, logger)
 
-    context 'when ssl true' do
-      before do
-        AppConfig.stub(:use_ssl).and_return(true)
+        Config.included(app)
       end
 
-      it 'makes sure only webrick can be used' do
-        app.should_receive(:set).with(:server, %[webrick])
-        RestAssured::Config.included(app)
+      context 'when ssl true' do
+        before do
+          AppConfig.stub(:ssl).and_return(true)
+        end
+
+        it 'makes sure only webrick can be used' do
+          app.should_receive(:set).with(:server, %[webrick])
+          Config.included(app)
+        end
+
+        it 'sets up webrick ssl' do
+          OpenSSL::X509::Certificate.stub(:new).with( File.read( AppConfig.ssl_cert ) ).and_return('ssl_cert')
+          OpenSSL::PKey::RSA.stub(:new).with( File.read( AppConfig.ssl_key ) ).and_return('ssl_key')
+
+          ssl_config = {
+            :SSLEnable => true,
+            :SSLCertificate => 'ssl_cert',
+            :SSLPrivateKey  => 'ssl_key',
+            :SSLCertName => [ ["CN", WEBrick::Utils::getservername] ],
+            :SSLVerifyClient => OpenSSL::SSL::VERIFY_NONE 
+          }
+
+          app.should_receive(:set).with(:webrick, hash_including(ssl_config))
+          Config.included(app)
+        end
+
+        it 'does all that only if ssl true' do
+          AppConfig.stub(:ssl).and_return(false)
+
+          app.should_not_receive(:set).with(:webrick, anything)
+          Config.included(app)
+        end
+      end
+    end
+    
+    context 'cmd args array conversion' do
+      it 'converts true values in form of "value" => ["--#{value}"]' do
+        Config.build(:ssl => true)
+        Config.to_cmdargs.should == ['--ssl']
       end
 
-      it 'sets up webrick ssl' do
-        OpenSSL::X509::Certificate.stub(:new).with( File.read( AppConfig.ssl_cert ) ).and_return('ssl_cert')
-        OpenSSL::PKey::RSA.stub(:new).with( File.read( AppConfig.ssl_key ) ).and_return('ssl_key')
-
-        ssl_config = {
-          :SSLEnable => true,
-          :SSLCertificate => 'ssl_cert',
-          :SSLPrivateKey  => 'ssl_key',
-          :SSLCertName => [ ["CN", WEBrick::Utils::getservername] ],
-          :SSLVerifyClient => OpenSSL::SSL::VERIFY_NONE 
-        }
-
-        app.should_receive(:set).with(:webrick, hash_including(ssl_config))
-        RestAssured::Config.included(app)
+      it 'does not include false values' do
+        Config.build(:ssl => false)
+        Config.to_cmdargs.should_not include('--ssl')
       end
 
-      it 'does all that only if ssl true' do
-        AppConfig.stub(:use_ssl).and_return(false)
-        
-        app.should_not_receive(:set).with(:webrick, anything)
-        RestAssured::Config.included(app)
+      it 'converts key value pairs in form of "key => value" => ["--#{key}", "value"]' do
+        Config.build(:port => 1234, :database => ':memory:')
+        Config.to_cmdargs.each_slice(2) do |a|
+          (a == ['--port', '1234'] || a == ['--database', ':memory:']).should == true
+        end
       end
     end
   end