rest-assured 0.2.0.rc8 → 0.2.0

data/features/step_definitions/redirect_rules_steps.rb

@@ -1,16 +1,20 @@
 Given /^there are no redirect rules$/ do
-  Redirect.destroy_all
+  RestAssured::Models::Redirect.destroy_all
 end
 
 Then /^I should get (\d+)$/ do |code|
   last_response.status.should.to_s == code
 end
 
-When /^I register redirect with pattern "([^"]*)" and uri "([^"]*)"$/ do |pattern, uri|
-  post '/redirects', { :pattern => pattern, :to => uri }
+Given /^there is redirect with pattern "([^"]*)" and uri "([^"]*)"$/ do |pattern, url|
+  post '/redirects', { :pattern => pattern, :to => url }
   last_response.should be_ok
 end
 
+When /^I register redirect with pattern "([^"]*)" and uri "([^"]*)"$/ do |pattern, url|
+  Given %{there is redirect with pattern "#{pattern}" and uri "#{url}"}
+end
+
 Then /^it should redirect to "([^"]*)"$/ do |real_api_url|
   follow_redirect!
   last_response.header['Location'].should == real_api_url
@@ -18,7 +22,7 @@ end
 
 Given /^the following redirects exist:$/ do |redirects|
   redirects.hashes.each do |row|
-    Redirect.create(:pattern => row['pattern'], :to => row['to'])
+    RestAssured::Models::Redirect.create(:pattern => row['pattern'], :to => row['to'])
   end
 end
 
@@ -50,7 +54,7 @@ Given /^I choose to delete redirect with pattern "([^"]*)"$/ do |pattern|
 end
 
 When /^I reorder second redirect to be the first one$/ do
-  handler = find("#redirects #redirect_#{Redirect.last.id} td.handle")
+  handler = find("#redirects #redirect_#{RestAssured::Models::Redirect.last.id} td.handle")
   target = find('#redirects thead')
 
   handler.drag_to target
@@ -64,3 +68,18 @@ Then /^"([^"]*)" should be redirected to "([^"]*)"$/ do |missing_request, url|
 
   last_request.url.should == "#{url}#{missing_request}"
 end
+
+Given /^blank slate$/ do
+end
+
+Given /^there are some redirects$/ do
+  RestAssured::Models::Redirect.create(:pattern => 'something', :to => 'somewhere')
+end
+
+When /^I delete all redirects$/ do
+  delete '/redirects/all'
+end
+
+Then /^there should be no redirects$/ do
+  RestAssured::Models::Redirect.count.should == 0
+end

data/features/step_definitions/ruby_api_steps.rb

@@ -0,0 +1,69 @@
+Given /^there is a double$/ do
+  @double = RestAssured::Double.create(:fullpath => '/some/path', :content => 'some content', :verb => 'POST')
+end
+
+When /^that double gets requested$/ do
+  post @double.fullpath, { :foo => 'bar' }.to_json, "CONTENT_TYPE" => "application/json"
+  post @double.fullpath, { :fooz => 'baaz'}, 'SOME_HEADER' => 'header_data'
+end
+
+When /^I request call history for that double$/ do
+  @requests = @double.reload.requests
+end
+
+Then /^I should see history records for those requests$/ do
+  @requests.first.body.should == { :foo => 'bar' }.to_json
+  JSON.parse( @requests.first.rack_env )["CONTENT_TYPE"].should == 'application/json'
+
+  JSON.parse( @requests.last.params ).should == { 'fooz' => 'baaz' }
+  JSON.parse( @requests.last.rack_env )["SOME_HEADER"].should == 'header_data'
+end
+
+Then /^it should be empty$/ do
+  @requests.size.should == 0
+end
+
+Given /^I created a double:$/ do |string|
+  # expected string is:
+  # @double = RestAssured::Double.create(:fullpath => '/some/api', :verb => 'POST')
+  eval string
+end
+
+When /^that double gets requested (#{CAPTURE_A_NUMBER}) times$/ do |num|
+  num.times do
+    sleep 0.5
+    send(@double.verb.downcase, @double.fullpath)
+  end
+end
+
+When /^I wait for (\d+) requests:$/ do |num, string|
+  # expected string
+  # @double.wait_for_requests(3)
+
+  @wait_start = Time.now
+  @t = Thread.new do
+    begin
+      eval string
+    rescue RestAssured::MoreRequestsExpected => e
+      @more_reqs_exc = e
+    end
+  end
+end
+
+Then /^it should let me through$/ do
+  @t.join
+  @more_reqs_exc.should == nil
+end
+
+Then /^it should wait for (#{CAPTURE_A_NUMBER}) seconds(?: \(default timeout\))?$/ do |timeout|
+  @t.join
+  wait_time = Time.now - @wait_start
+  #(timeout..(timeout+1)).should cover(wait_time) # cover() only avilable in 1.9
+  wait_time.should >= timeout
+  wait_time.should < timeout + 1
+end
+
+Then /^it should raise MoreRequestsExpected error after with the following message:$/ do |string|
+  @more_reqs_exc.should be_instance_of RestAssured::MoreRequestsExpected
+  @more_reqs_exc.message.should =~ /#{string}/
+end

data/features/support/env.rb

@@ -3,7 +3,7 @@ require 'rubygems'
 require 'spork'
 
 Spork.prefork do
-  require 'rspec/expectations'
+  require 'rspec'
   require 'rack/test'
   require 'capybara'
   require 'capybara/firebug'
@@ -77,6 +77,8 @@ Spork.each_run do
   After do
     sleep 0.1
     DatabaseCleaner.clean
+
+    @t.join if @t.is_a?(Thread)
   end
 end
 

data/lib/rest-assured.rb

@@ -1,5 +1,6 @@
 require 'rubygems'
 require 'sinatra/base'
+require 'sinatra/handler_options_patch'
 require 'haml'
 require 'rack-flash'
 require 'sinatra/partials'
@@ -14,7 +15,7 @@ require 'rest-assured/routes/response'
 module RestAssured
   class Application < Sinatra::Base
 
-    include RestAssured::Config
+    include Config
 
     enable :method_override
 

data/lib/rest-assured/client/resources.rb

@@ -1,8 +1,18 @@
 require 'active_resource'
 
 module RestAssured
-  module Client
-    class Double < ActiveResource::Base
+  class MoreRequestsExpected < StandardError; end
+
+  class Double < ActiveResource::Base
+    def wait_for_requests(n, opts = {})
+      timeout = opts[:timeout] || 5
+
+      timeout.times do
+        sleep 1
+        reload
+        return if requests.count >= n
+      end
+      raise MoreRequestsExpected.new("Expected #{n} requests. Got #{requests.count}.")
     end
   end
 end

data/lib/rest-assured/config.rb

@@ -1,6 +1,8 @@
 require 'logger'
 require 'active_record'
 require 'active_support/core_ext/kernel/reporting'
+require 'webrick'
+require 'webrick/https'
 
 module RestAssured
   module Config
@@ -37,11 +39,13 @@ module RestAssured
                               File.expand_path("../../../#{AppConfig.environment}.log", __FILE__)
                             end
       build_db_config
+      build_ssl_config
     end
 
     def self.included(klass)
       init_logger
       setup_db
+      setup_ssl(klass) if AppConfig.use_ssl
 
       klass.set :port, AppConfig.port
       klass.set :environment, AppConfig.environment
@@ -52,6 +56,19 @@ module RestAssured
 
     private
 
+      def self.setup_ssl(klass)
+        ssl_config = {
+          :SSLEnable => true,
+          :SSLCertificate => OpenSSL::X509::Certificate.new( File.read( AppConfig.ssl_cert ) ),
+          :SSLPrivateKey => OpenSSL::PKey::RSA.new( File.read( AppConfig.ssl_key ) ),
+          :SSLCertName => [ ["CN", WEBrick::Utils::getservername] ],
+          :SSLVerifyClient => OpenSSL::SSL::VERIFY_NONE 
+        }
+
+        klass.set :server, %[webrick]
+        klass.set :webrick, ssl_config
+      end
+
       def self.setup_db
         setup_db_logging
         connect_db
@@ -118,6 +135,7 @@ module RestAssured
                                 opts = {
                                   :adapter => 'mysql',
                                   :reconnect => true,
+                                  :pool => 20,
                                   :user => AppConfig.user || 'root',
                                   :database => AppConfig.database || default_database
                                 }
@@ -132,6 +150,12 @@ module RestAssured
                                 raise "Unsupported db adapter '#{AppConfig.adapter}'. Valid adapters are sqlite and mysql"
                               end
       end
+
+      def self.build_ssl_config
+        AppConfig.use_ssl ||= false
+        AppConfig.ssl_cert ||= File.expand_path('../../../ssl/localhost.crt', __FILE__)
+        AppConfig.ssl_key ||= File.expand_path('../../../ssl/localhost.key', __FILE__)
+      end
   end
 end
 

data/lib/rest-assured/models/double.rb

@@ -1,43 +1,47 @@
 require 'net/http'
 
-class Double < ActiveRecord::Base
-  attr_accessible :fullpath, :content, :description, :verb, :status
+module RestAssured
+  module Models
+    class Double < ActiveRecord::Base
+      attr_accessible :fullpath, :content, :description, :verb, :status
 
-  VERBS = %w{GET POST PUT DELETE}
-  STATUSES = Net::HTTPResponse::CODE_TO_OBJ.keys.map(&:to_i)
+      VERBS = %w{GET POST PUT DELETE}
+      STATUSES = Net::HTTPResponse::CODE_TO_OBJ.keys.map(&:to_i)
 
-  validates_presence_of :fullpath
-  validates_inclusion_of :verb, :in => VERBS
-  validates_inclusion_of :status, :in => STATUSES
+      validates_presence_of :fullpath
+      validates_inclusion_of :verb, :in => VERBS
+      validates_inclusion_of :status, :in => STATUSES
 
-  before_save :toggle_active
-  before_validation :set_verb
-  before_validation :set_status
-  after_destroy :set_active
+      before_save :toggle_active
+      before_validation :set_verb
+      before_validation :set_status
+      after_destroy :set_active
 
-  has_many :requests, :dependent => :destroy
+      has_many :requests, :dependent => :destroy
 
-  private
-    def toggle_active
-      ne = id ? '!=' : 'IS NOT'
+      private
+      def toggle_active
+        ne = id ? '!=' : 'IS NOT'
 
-      if active && Double.where("fullpath = ? AND active = ? AND id #{ne} ?", fullpath, true, id).exists?
-        Double.where("fullpath = ? AND id #{ne} ?", fullpath, id).update_all :active => false
+        if active && Double.where("fullpath = ? AND active = ? AND id #{ne} ?", fullpath, true, id).exists?
+          Double.where("fullpath = ? AND id #{ne} ?", fullpath, id).update_all :active => false
+        end
       end
-    end
 
-    def set_verb
-      self.verb = 'GET' unless verb.present?
-    end
+      def set_verb
+        self.verb = 'GET' unless verb.present?
+      end
 
-    def set_status
-      self.status = 200 unless status.present?
-    end
+      def set_status
+        self.status = 200 unless status.present?
+      end
 
-    def set_active
-      if active && f = Double.where(:fullpath => fullpath).last
-        f.active = true
-        f.save
+      def set_active
+        if active && f = Double.where(:fullpath => fullpath).last
+          f.active = true
+          f.save
+        end
       end
     end
+  end
 end

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

@@ -1,35 +1,39 @@
-class Redirect < ActiveRecord::Base
-  attr_accessible :pattern, :to, :position
+module RestAssured
+  module Models
+    class Redirect < ActiveRecord::Base
+      attr_accessible :pattern, :to, :position
 
-  validates_presence_of :pattern, :to
+      validates_presence_of :pattern, :to
 
-  scope :ordered, order('position')
+      scope :ordered, order('position')
 
-  before_create :assign_position
+      before_create :assign_position
 
-  def self.update_order(ordered_redirect_ids)
-    success = true
+      def self.update_order(ordered_redirect_ids)
+        success = true
 
-    transaction do
-      begin
-        ordered_redirect_ids.each_with_index do |r_id, idx|
-          r = find(r_id)
-          r.position = idx
-          r.save!
+        transaction do
+          begin
+            ordered_redirect_ids.each_with_index do |r_id, idx|
+              r = find(r_id)
+              r.position = idx
+              r.save!
+            end
+          rescue => e
+            # TODO log exception
+            puts e.inspect
+            success = false
+            raise ActiveRecord::Rollback
+          end
         end
-      rescue => e
-        # TODO log exception
-        puts e.inspect
-        success = false
-        raise ActiveRecord::Rollback
+        success
       end
-    end
-    success
-  end
 
-  private
+      private
 
-    def assign_position
-      self.position = ( self.class.maximum(:position) || -1 ) + 1
+      def assign_position
+        self.position = ( self.class.maximum(:position) || -1 ) + 1
+      end
     end
+  end
 end

data/lib/rest-assured/models/request.rb

@@ -1,12 +1,16 @@
-class Request < ActiveRecord::Base
-  belongs_to :double
+module RestAssured
+  module Models
+    class Request < ActiveRecord::Base
+      belongs_to :double
 
-  validates_presence_of :rack_env
+      validates_presence_of :rack_env
 
-  after_create :save_created_at
+      after_create :save_created_at
 
-  private
-    def save_created_at
-      self.created_at = Time.now
+      private
+        def save_created_at
+          self.created_at = Time.now
+        end
     end
+  end
 end

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

@@ -8,18 +8,18 @@ module RestAssured
       end
 
       router.get '/doubles' do
-        @doubles = Double.all
+        @doubles = Models::Double.all
         haml :'doubles/index'
       end
 
       router.get '/doubles/new' do
-        @double = Double.new
+        @double = Models::Double.new
         haml :'doubles/new'
       end
 
       router.get '/doubles/:id.json' do |id|
         begin
-          double = Double.find(id)
+          double = Models::Double.find(id)
           body double.to_json(:include => :requests)
         rescue ActiveRecord::RecordNotFound
           status 404
@@ -29,7 +29,7 @@ module RestAssured
       router.post /^\/doubles(\.json)?$/ do |passes_json|
         f = { :fullpath => params['fullpath'], :content => params['content'], :description => params['description'], :verb => params['verb'], :status => params['status'] }
 
-        @double = Double.create(passes_json ? JSON.parse(request.body.read)['double'] : ( params['double'] || f )) 
+        @double = Models::Double.create(passes_json ? JSON.parse(request.body.read)['double'] : ( params['double'] || f )) 
 
         if browser?
           if @double.errors.blank?
@@ -50,12 +50,12 @@ module RestAssured
       end
 
       router.get %r{/doubles/(\d+)/edit} do |id|
-        @double = Double.find(id)
+        @double = Models::Double.find(id)
         haml :'doubles/edit'
       end
 
       router.put %r{/doubles/(\d+)} do |id|
-        @double = Double.find(id)
+        @double = Models::Double.find(id)
 
         if request.xhr?
           if params['active']
@@ -77,14 +77,14 @@ module RestAssured
       end
 
       router.delete %r{/doubles/(\d+)} do |id|
-        if Double.destroy(id)
+        if Models::Double.destroy(id)
           flash[:notice] = 'Double deleted'
           redirect '/doubles'
         end
       end
 
       router.delete '/doubles/all' do
-        status Double.delete_all ? 200 : 500
+        status Models::Double.delete_all ? 200 : 500
       end
     end
   end