rest-assured 0.2.0.rc8 → 0.2.0

data/lib/rest-assured/routes/redirect.rb

@@ -2,17 +2,17 @@ module RestAssured
   module RedirectRoutes
     def self.included(router)
       router.get '/redirects' do
-        @redirects = Redirect.ordered
+        @redirects = Models::Redirect.ordered
         haml :'redirects/index'
       end
 
       router.get '/redirects/new' do
-        @redirect = Redirect.new
+        @redirect = Models::Redirect.new
         haml :'redirects/new'
       end
 
       router.post '/redirects' do
-        @redirect = Redirect.create(params['redirect'] || { :pattern => params['pattern'], :to => params['to'] })
+        @redirect = Models::Redirect.create(params['redirect'] || { :pattern => params['pattern'], :to => params['to'] })
 
         if browser?
           if @redirect.errors.blank?
@@ -31,12 +31,12 @@ module RestAssured
       end
 
       router.get %r{/redirects/(\d+)/edit} do |id|
-        @redirect = Redirect.find(id)
+        @redirect = Models::Redirect.find(id)
         haml :'redirects/edit'
       end
 
       router.put %r{/redirects/(\d+)} do |id|
-        @redirect = Redirect.find(id)
+        @redirect = Models::Redirect.find(id)
 
         @redirect.update_attributes(params['redirect'])
 
@@ -51,7 +51,7 @@ module RestAssured
 
       router.put '/redirects/reorder' do
         if params['redirect']
-          if Redirect.update_order(params['redirect'])
+          if Models::Redirect.update_order(params['redirect'])
             'Changed'
           else
             'Crumps! It broke'
@@ -60,14 +60,14 @@ module RestAssured
       end
 
       router.delete %r{/redirects/(\d+)} do |id|
-        if Redirect.destroy(id)
+        if Models::Redirect.destroy(id)
           flash[:notice] = 'Redirect deleted'
           redirect '/redirects'
         end
       end
 
       router.delete '/redirects/all' do
-        status Redirect.delete_all ? 200 : 500
+        status Models::Redirect.delete_all ? 200 : 500
       end
     end
   end

data/lib/rest-assured/routes/response.rb

@@ -1,20 +1,22 @@
-class Response
-  def self.perform(app)
-    request = app.request
+module RestAssured
+  class Response
+    def self.perform(app)
+      request = app.request
 
-    if d = Double.where(:fullpath => request.fullpath, :active => true, :verb => request.request_method).first
-      request.body.rewind
-      body   = request.body.read #without temp variable ':body = > body' is always nil. mistery
-      env    = request.env.except('rack.input', 'rack.errors', 'rack.logger')
+      if d = Models::Double.where(:fullpath => request.fullpath, :active => true, :verb => request.request_method).first
+        request.body.rewind
+        body   = request.body.read #without temp variable ':body = > body' is always nil. mistery
+        env    = request.env.except('rack.input', 'rack.errors', 'rack.logger')
 
-      d.requests.create!(:rack_env => env.to_json, :body => body, :params => request.params.to_json)
+        d.requests.create!(:rack_env => env.to_json, :body => body, :params => request.params.to_json)
 
-      app.body d.content
-      app.status d.status
-    elsif r = Redirect.ordered.find { |r| request.fullpath =~ /#{r.pattern}/ }
-      app.redirect( "#{r.to}#{request.fullpath}" )
-    else
-      app.status 404
+        app.body d.content
+        app.status d.status
+      elsif r = Models::Redirect.ordered.find { |r| request.fullpath =~ /#{r.pattern}/ }
+        app.redirect( "#{r.to}#{request.fullpath}" )
+      else
+        app.status 404
+      end
     end
   end
 end

data/lib/rest-assured/version.rb

@@ -1,3 +1,3 @@
 module RestAssured
-  VERSION = '0.2.0.rc8'
+  VERSION = '0.2.0'
 end

data/lib/sinatra/handler_options_patch.rb

@@ -0,0 +1,25 @@
+module Sinatra
+  class Base
+    class << self
+      def run!(options={})
+        set options
+        handler      = detect_rack_handler
+        handler_name = handler.name.gsub(/.*::/, '')
+        # handler specific options use the lower case handler name as hash key, if present
+        handler_opts = begin
+                         send(handler_name.downcase)
+                       rescue NoMethodError
+                         {}
+                       end
+        puts "== Sinatra/#{Sinatra::VERSION} has taken the stage " +
+          "on #{port} for #{environment} with backup from #{handler_name}" unless handler_name =~/cgi/i
+        handler.run self, handler_opts.merge(:Host => bind, :Port => port) do |server|
+          [:INT, :TERM].each { |sig| trap(sig) { quit!(server, handler_name) } }
+          set :running, true
+        end
+      rescue Errno::EADDRINUSE => e
+        puts "== Someone is already performing on port #{port}!"
+      end
+    end
+  end
+end

data/spec/client/resource_double_spec.rb

@@ -1,7 +1,7 @@
 require 'uri'
 require File.expand_path('../../spec_helper', __FILE__)
 
-module RestAssured::Client
+module RestAssured
   describe Double do
     before do
       @orig_addr = RestAssured::Client.config.server_address
@@ -20,11 +20,11 @@ module RestAssured::Client
 
     it 'creates new double' do
       d = Double.create :fullpath => '/some/api', :content => 'content'
-      ::Double.where(:fullpath => d.fullpath, :content => d.content).should exist
+      Models::Double.where(:fullpath => d.fullpath, :content => d.content).should exist
     end
 
     it 'finds exising double' do
-      d = ::Double.create :fullpath => '/some/api', :content => 'content'
+      d = Models::Double.create :fullpath => '/some/api', :content => 'content'
 
       dd = Double.find(d.id)
 
@@ -33,9 +33,9 @@ module RestAssured::Client
     end
 
     it 'shows request history' do
-      d = ::Double.create :fullpath => '/some/api', :content => 'content'
-      d.requests << Request.create(:rack_env => 'rack_env json', :body => 'body', :params => 'params')
-      d.requests << Request.create(:rack_env => 'different rack_env', :body => 'other body', :params => 'more params')
+      d = Models::Double.create :fullpath => '/some/api', :content => 'content'
+      d.requests << Models::Request.create(:rack_env => 'rack_env json', :body => 'body', :params => 'params')
+      d.requests << Models::Request.create(:rack_env => 'different rack_env', :body => 'other body', :params => 'more params')
 
       dd = Double.find(d.id)
       dd.requests.size.should == 2
@@ -43,5 +43,41 @@ module RestAssured::Client
       dd.requests.first.params.should == 'params'
       dd.requests.last.body.should == 'other body'
     end
+
+    context 'when waits requests' do
+      after do
+        @t.join if @t.respond_to?(:join)
+      end
+
+      it 'waits for specified number of requests' do
+        d = Models::Double.create :fullpath => '/some/api', :content => 'content'
+        dd = Double.find(d.id)
+
+        @t = Thread.new do
+          3.times do
+            sleep 1
+            d.requests << Models::Request.create(:rack_env => 'rack_env json', :body => 'body', :params => 'params')
+          end
+        end
+
+        dd.wait_for_requests(2)
+
+        dd.requests.count.should >= 2
+      end
+
+      it 'raises exception if requests have not happened within timeout' do
+        d = Models::Double.create :fullpath => '/some/api', :content => 'content'
+        dd = Double.find(d.id)
+        dd.stub(:sleep)
+
+        @t = Thread.new do
+          2.times do
+            d.requests << Models::Request.create(:rack_env => 'rack_env json', :body => 'body', :params => 'params')
+          end
+        end
+
+        lambda { dd.wait_for_requests(3) }.should raise_error(MoreRequestsExpected, 'Expected 3 requests. Got 2.')
+      end
+    end
   end
 end

data/spec/config_spec.rb

@@ -1,5 +1,7 @@
 require File.expand_path('../../lib/rest-assured/config', __FILE__)
 require 'rack'
+require 'openssl'
+require 'webrick'
 
 describe RestAssured::Config do
   #this is thoroughly covered in cucumber (since there it also serves documentation purposes)
@@ -94,5 +96,38 @@ describe RestAssured::Config do
       RestAssured::Config.included(app)
     end
 
+    context 'when ssl true' do
+      before do
+        AppConfig.stub(:use_ssl).and_return(true)
+      end
+
+      it 'makes sure only webrick can be used' do
+        app.should_receive(:set).with(:server, %[webrick])
+        RestAssured::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))
+        RestAssured::Config.included(app)
+      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)
+      end
+    end
   end
 end

data/spec/functional/double_routes_spec.rb

@@ -1,149 +1,151 @@
 require File.expand_path('../../spec_helper', __FILE__)
 
-describe 'Double routes' do
-  let :test_double do
-    { :fullpath => '/api/google?a=5', :content => 'some awesome content', :verb => 'POST', :status => '201' }
-  end
-  let :valid_params do
-    { 'double[fullpath]' =>  test_double[:fullpath], 'double[content]' => test_double[:content], 'double[verb]' => test_double[:verb], 'double[status]' => test_double[:status] }
-  end
-  let :invalid_params do
-    valid_params.except('double[fullpath]')
-  end
-
-  describe "through ui", :ui => true do
-    it "shows doubles page by default" do
-      visit '/'
-      current_path.should == '/doubles'
+module RestAssured
+  describe 'Double routes' do
+    let :test_double do
+      { :fullpath => '/api/google?a=5', :content => 'some awesome content', :verb => 'POST', :status => '201' }
+    end
+    let :valid_params do
+      { 'double[fullpath]' =>  test_double[:fullpath], 'double[content]' => test_double[:content], 'double[verb]' => test_double[:verb], 'double[status]' => test_double[:status] }
+    end
+    let :invalid_params do
+      valid_params.except('double[fullpath]')
     end
 
-    it "shows list of doubles" do
-      f = Double.create test_double
+    describe "through ui", :ui => true do
+      it "shows doubles page by default" do
+        visit '/'
+        current_path.should == '/doubles'
+      end
 
-      visit '/doubles'
+      it "shows list of doubles" do
+        f = Models::Double.create test_double
 
-      page.should have_content(f.fullpath)
-    end
+        visit '/doubles'
 
-    it "shows form for creating new double" do
-      visit '/doubles/new'
+        page.should have_content(f.fullpath)
+      end
 
-      page.should have_css('#double_fullpath')
-      page.should have_css('#double_content')
-      page.should have_css('#double_description')
-    end
+      it "shows form for creating new double" do
+        visit '/doubles/new'
 
-    it "creates double" do
-      post '/doubles', valid_params
-      follow_redirect!
+        page.should have_css('#double_fullpath')
+        page.should have_css('#double_content')
+        page.should have_css('#double_description')
+      end
 
-      last_request.fullpath.should == '/doubles'
-      last_response.body.should =~ /Double created/
-      Double.exists?(test_double).should be true
-    end
+      it "creates double" do
+        post '/doubles', valid_params
+        follow_redirect!
 
-    it "reports failure when creating with invalid parameters" do
-      post '/doubles', invalid_params
+        last_request.fullpath.should == '/doubles'
+        last_response.body.should =~ /Double created/
+        Models::Double.exists?(test_double).should be true
+      end
 
-      last_response.should be_ok
-      last_response.body.should =~ /Crumps!.*Fullpath can't be blank/
-    end
+      it "reports failure when creating with invalid parameters" do
+        post '/doubles', invalid_params
 
-    it "brings up double edit form" do
-      f = Double.create test_double
-      visit "/doubles/#{f.id}/edit"
+        last_response.should be_ok
+        last_response.body.should =~ /Crumps!.*Fullpath can't be blank/
+      end
 
-      find('#double_fullpath').value.should == f.fullpath
-      find('#double_content').value.should == f.content
-    end
+      it "brings up double edit form" do
+        f = Models::Double.create test_double
+        visit "/doubles/#{f.id}/edit"
 
-    it "updates double" do
-      f = Double.create test_double
+        find('#double_fullpath').value.should == f.fullpath
+        find('#double_content').value.should == f.content
+      end
 
-      put "/doubles/#{f.id}", 'double[fullpath]' => '/some/other/api'
-      follow_redirect!
-      
-      last_request.fullpath.should == '/doubles'
-      last_response.body.should =~ /Double updated/
-      f.reload.fullpath.should == '/some/other/api'
-    end
+      it "updates double" do
+        f = Models::Double.create test_double
 
-    it "chooses active double" do
-      f = Double.create test_double.merge!(:active => false)
+        put "/doubles/#{f.id}", 'double[fullpath]' => '/some/other/api'
+        follow_redirect!
 
-      ajax "/doubles/#{f.id}", :as => :put, :active => true
+        last_request.fullpath.should == '/doubles'
+        last_response.body.should =~ /Double updated/
+        f.reload.fullpath.should == '/some/other/api'
+      end
 
-      last_response.should be_ok
-      last_response.body.should == 'Changed'
-    end
+      it "chooses active double" do
+        f = Models::Double.create test_double.merge!(:active => false)
 
-    it "deletes double" do
-      f = Double.create test_double
+        ajax "/doubles/#{f.id}", :as => :put, :active => true
 
-      delete "/doubles/#{f.id}"
-      follow_redirect!
+        last_response.should be_ok
+        last_response.body.should == 'Changed'
+      end
 
-      last_response.should be_ok
-      last_response.body.should =~ /Double deleted/
-      
-      Double.exists?(test_double).should be_false
-    end
-  end
+      it "deletes double" do
+        f = Models::Double.create test_double
 
-  describe "through REST api", :ui => false do
-    it "creates double" do
-      post '/doubles', test_double
+        delete "/doubles/#{f.id}"
+        follow_redirect!
 
-      last_response.should be_ok
-      Double.exists?(test_double).should be_true
+        last_response.should be_ok
+        last_response.body.should =~ /Double deleted/
+
+        Models::Double.exists?(test_double).should be_false
+      end
     end
 
-    it "reports failure when creating with invalid parameters" do
-      post '/doubles', test_double.except(:fullpath)
+    describe "through REST api", :ui => false do
+      it "creates double" do
+        post '/doubles', test_double
 
-      last_response.should_not be_ok
-      last_response.body.should =~ /\{"fullpath":\["can't be blank"\]\}/
-    end
+        last_response.should be_ok
+        Models::Double.exists?(test_double).should be_true
+      end
 
-    it "deletes all doubles" do
-      Double.create test_double
+      it "reports failure when creating with invalid parameters" do
+        post '/doubles', test_double.except(:fullpath)
 
-      delete '/doubles/all'
+        last_response.should_not be_ok
+        last_response.body.should =~ /\{"fullpath":\["can't be blank"\]\}/
+      end
 
-      last_response.should be_ok
-      Double.count.should == 0
-    end
-  end
+      it "deletes all doubles" do
+        Models::Double.create test_double
 
-  describe 'through REST (ActiveResource compatible) json api', :ui => false do
-    it "creates double as AR resource" do
-      post '/doubles.json', { :double => test_double }.to_json, 'CONTENT_TYPE' => 'Application/json'
+        delete '/doubles/all'
 
-      last_response.should be_ok
-      Double.exists?(test_double).should be_true
-      last_response.body.should == Double.where(test_double).first.to_json
+        last_response.should be_ok
+        Models::Double.count.should == 0
+      end
     end
 
-    it "reports failure when creating with invalid parameters" do
-      post '/doubles.json', { :double => test_double.except(:fullpath) }.to_json, 'CONTENT_TYPE' => 'Application/json'
+    describe 'through REST (ActiveResource compatible) json api', :ui => false do
+      it "creates double as AR resource" do
+        post '/doubles.json', { :double => test_double }.to_json, 'CONTENT_TYPE' => 'Application/json'
 
-      last_response.should_not be_ok
-      last_response.body.should =~ /\{"fullpath":\["can't be blank"\]\}/
-    end
+        last_response.should be_ok
+        Models::Double.exists?(test_double).should be_true
+        last_response.body.should == Models::Double.where(test_double).first.to_json
+      end
 
-    it 'loads double as AR resource' do
-      d = Double.create test_double
+      it "reports failure when creating with invalid parameters" do
+        post '/doubles.json', { :double => test_double.except(:fullpath) }.to_json, 'CONTENT_TYPE' => 'Application/json'
 
-      get "/doubles/#{d.id}.json", 'CONTENT_TYPE' => 'Application/json'
+        last_response.should_not be_ok
+        last_response.body.should =~ /\{"fullpath":\["can't be blank"\]\}/
+      end
 
-      last_response.should be_ok
-      last_response.body.should == d.to_json(:include => :requests)
-    end
+      it 'loads double as AR resource' do
+        d = Models::Double.create test_double
+
+        get "/doubles/#{d.id}.json", 'CONTENT_TYPE' => 'Application/json'
+
+        last_response.should be_ok
+        last_response.body.should == d.to_json(:include => :requests)
+      end
+
+      it '404s if double is not found' do
+        get "/doubles/345345.json", 'CONTENT_TYPE' => 'Application/json'
 
-    it '404s if double is not found' do
-      get "/doubles/345345.json", 'CONTENT_TYPE' => 'Application/json'
-      
-      last_response.status.should == 404
+        last_response.status.should == 404
+      end
     end
   end
 end