rest-assured 0.1.4 → 0.2.0.rc1

data/README.markdown

@@ -28,20 +28,20 @@ This starts an instance of rest-assured on port 4578 (changable with --port opti
 
 Double is a stub/mock of a particular external call. There is the following rest API for setting up doubles:
 
-* `POST '/doubles', { fullpath: path, content: content, method: method }`
+* `POST '/doubles', { fullpath: path, content: content, verb: verb }`
   Creates double with the following parameters:
 
   - __fullpath__ - e.g., `/some/api/object`, or with parameters in query string (useful for doubling GETs) - `/some/other/api/object?a=2&b=c`. Mandatory.
   - __content__ - whatever you want this double to respond with. Mandatory.
-  - __method__ - one of http the following http verbs: GET, POST, PUT, DELETE. Optional. GET is default.
+  - __verb__ - one of http the following http verbs: GET, POST, PUT, DELETE. Optional. GET is default.
 
   Example (using ruby RestClient):
   
-    RestClient.post 'http://localhost:4578:/doubles', { request_fullpath: '/api/v2/products?type=fresh', method: 'GET', content: 'this is list of products' }
+    RestClient.post 'http://localhost:4578/doubles', { fullpath: '/api/v2/products?type=fresh', verb: 'GET', content: 'this is list of products' }
 
   Now GETting http://localhost:4578/api/v2/products?type=fresh (in browser for instance) should return "this is list of products".
 
-  If there is more than one double for the same request\_fullpath and method, the last created one gets served. In UI you can manually control which double is 'active' (gets served).
+  If there is more than one double for the same request\_fullpath and verb, the last created one gets served. In UI you can manually control which double is 'active' (gets served).
 
 * `DELETE '/doubles/all'`
   Deletes all doubles.
@@ -59,7 +59,7 @@ It is sometimes desirable to only double certain calls while letting others thro
 
     RestClient.post 'http://localhost:4578/redirects', { pattern: '^/auth', to: 'https://myserver.com/api' }
 
-  Now request (any method) to http://localhost:4578/auth/services/1 will get redirected to https://myserver.com/api/auth/services/1. Provided of course there is no double matched for that fullpath and method.
+  Now request (any verb) to http://localhost:4578/auth/services/1 will get redirected to https://myserver.com/api/auth/services/1. Provided of course there is no double matched for that fullpath and verb.
   Much like rewrite rules, redirects are evaluated in order (of creation). In UI you can manually rearrange the order.
 
 ### Storage
@@ -75,7 +75,7 @@ It is sometimes useful to see what requests rest-assured is being hit. Either to
 * Implement expectations
 * Support headers (extends previous point)
 * Ruby client library
-* Support methods in UI (at the moment it is always GET)
+* Support verbs in UI (at the moment it is always GET)
 * Don't allow to double internal routes. Just in case
 
 ## Author

data/db/migrate/20111013122857_create_requests.rb

@@ -0,0 +1,15 @@
+class CreateRequests < ActiveRecord::Migration
+  def self.up
+    create_table :requests do |t|
+      t.integer :double_id
+      t.text :params
+      t.text :body
+      t.text :rack_env
+      t.datetime :created_at
+    end
+  end
+
+  def self.down
+    drop_table :requests
+  end
+end

data/db/migrate/20111016174101_rename_method_to_verb.rb

@@ -0,0 +1,9 @@
+class RenameMethodToVerb < ActiveRecord::Migration
+  def self.up
+    rename_column :doubles, :method, :verb
+  end
+
+  def self.down
+    rename_column :doubles, :verb, :method
+  end
+end

data/features/call_history.feature

@@ -0,0 +1,16 @@
+Feature: check double's call history
+  In order to verify outcomes of my app that take form of http requests
+  As test developer
+  I want to be able to get double 'call history' 
+
+  Scenario: no calls made to double
+    Given there is a double
+    When I request call history for that double
+    Then it should be empty
+
+  @now
+  Scenario: some calls made to double
+    Given there is a double
+    When that double gets requested
+    And I request call history for that double
+    Then I should see history records for those requests

data/features/doubles_via_api.feature

@@ -4,11 +4,11 @@ Feature: use doubles via api
   I want to mock rest services my app is consuming from
 
   Scenario Outline: create double
-    When I create a double with "<fullpath>" as fullpath, "<content>" as response content and "<method>" as request method
-    Then there should be 1 double with "<fullpath>" as fullpath, "<content>" as response content and "<result_method>" as request method
+    When I create a double with "<fullpath>" as fullpath, "<content>" as response content and "<verb>" as request verb
+    Then there should be 1 double with "<fullpath>" as fullpath, "<content>" as response content and "<result_verb>" as request verb
 
     Examples:
-      | fullpath           | content      | method | result_method |
+      | fullpath           | content      | verb | result_verb |
       | /api/something     | created      | POST   | POST          |
       | /api/sss           | changed      | PUT    | PUT           |
       | /api/asdfsf        | removed      | DELETE | DELETE        |
@@ -16,12 +16,12 @@ Feature: use doubles via api
       | /api/some?a=3&b=dd | more content |        | GET           |
 
   Scenario Outline: request fullpath that matches double
-    Given there is double with "<fullpath>" as fullpath, "<content>" as response content and "<method>" as request method
-    When I "<method>" "<fullpath>"
+    Given there is double with "<fullpath>" as fullpath, "<content>" as response content and "<verb>" as request verb
+    When I "<verb>" "<fullpath>"
     Then I should get "<content>" in response content
 
     Examples:
-      | fullpath           | content      | method |
+      | fullpath           | content      | verb |
       | /api/something     | created      | POST   |
       | /api/sss           | changed      | PUT    |
       | /api/asdfsf        | removed      | DELETE |

data/features/step_definitions/call_history_steps.rb

@@ -0,0 +1,24 @@
+Given /^there is a double$/ do
+  @double = RestAssured::Client::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

data/features/step_definitions/doubles_steps.rb

@@ -9,8 +9,8 @@ When /^I create a double with "([^"]*)" as fullpath and "([^"]*)" as response co
   last_response.should be_ok
 end
 
-When /^I create a double with "([^"]*)" as fullpath, "([^"]*)" as response content and "([^"]*)" as request method$/ do |fullpath, content, method|
-  post '/doubles', { :fullpath => fullpath, :content => content, :method => method }
+When /^I create a double with "([^"]*)" as fullpath, "([^"]*)" as response content and "([^"]*)" as request verb$/ do |fullpath, content, verb|
+  post '/doubles', { :fullpath => fullpath, :content => content, :verb => verb }
   last_response.should be_ok
 end
 
@@ -18,16 +18,16 @@ Then /^there should be (#{CAPTURE_A_NUMBER}) double with "([^"]*)" as fullpath a
   Double.where(:fullpath => fullpath, :content => content).count.should == 1
 end
 
-Then /^there should be (#{CAPTURE_A_NUMBER}) double with "([^"]*)" as fullpath, "([^"]*)" as response content and "([^"]*)" as request method$/ do |n, fullpath, content, method|
-  Double.where(:fullpath => fullpath, :content => content, :method => method).count.should == n
+Then /^there should be (#{CAPTURE_A_NUMBER}) double with "([^"]*)" as fullpath, "([^"]*)" as response content and "([^"]*)" as request verb$/ do |n, fullpath, content, verb|
+  Double.where(:fullpath => fullpath, :content => content, :verb => verb).count.should == n
 end
 
 Given /^there is double with "([^"]*)" as fullpath and "([^"]*)" as response content$/ do |fullpath, content|
   Double.create(:fullpath => fullpath, :content => content)
 end
 
-Given /^there is double with "([^"]*)" as fullpath, "([^"]*)" as response content and "([^"]*)" as request method$/ do |fullpath, content, method|
-  Double.create(:fullpath => fullpath, :content => content, :method => method)
+Given /^there is double with "([^"]*)" as fullpath, "([^"]*)" as response content and "([^"]*)" as request verb$/ do |fullpath, content, verb|
+  Double.create(:fullpath => fullpath, :content => content, :verb => verb)
 end
 
 Given /^I register "([^"]*)" as fullpath and "([^"]*)" as response content$/ do |fullpath, content|
@@ -39,8 +39,8 @@ When /^I request "([^"]*)"$/ do |fullpath|
   get fullpath
 end
 
-When /^I "([^"]*)" "([^"]*)"$/ do |method, fullpath|
-  send(method.downcase, fullpath)
+When /^I "([^"]*)" "([^"]*)"$/ do |verb, fullpath|
+  send(verb.downcase, fullpath)
 end
 
 Then /^I should get "([^"]*)" in response content$/ do |content|
@@ -141,3 +141,4 @@ end
 Then /^I should be asked to confirm delete$/ do
   page.driver.browser.switch_to.alert.accept
 end
+

data/features/support/env.rb

@@ -33,11 +33,27 @@ Spork.prefork do
   end
 
   World(Capybara, Rack::Test::Methods, RackHeaderHack)
+
 end
 
 
 Spork.each_run do
   require 'rest-assured'
+  require 'rest-assured/client'
+  require File.expand_path('../test-server', __FILE__)
+
+  at_exit do
+    TestServer.stop
+  end
+
+  TestServer.start(:port => 9876)
+
+  while not TestServer.up?
+    puts 'Waiting for TestServer to come up...'
+    sleep 1
+  end
+
+  RestAssured::Client.config.server_address = 'http://localhost:9876'
 
   def app
     RestAssured::Application

data/features/support/test-server.rb

@@ -0,0 +1,46 @@
+require 'net/http'
+
+# This is only needed till I get ActiveResource going through rack-test
+class TestServer
+  @pid_file = "./rest-assured.pid"
+
+  def self.start(opts = {})
+    @server_port = opts[:port] || 9876
+
+    print 'Starting TestServer server... '
+
+    p = Process.fork do
+      if get_pid
+        print "\nPrevious TestServer instance appears to be running. Will be using it."
+      else
+        Process.exec("bundle exec rest-assured -p #{@server_port}")
+      end
+    end
+
+    Process.detach(p)
+    puts 'Done.'
+  end
+
+  def self.stop
+    print 'Shutting down TestServer server... '
+    Process.kill('TERM', get_pid.to_i) rescue puts( "Failed to kill TestServer server: #{$!}" )
+    puts 'Done.'
+  end
+
+  def self.server_address
+    "http://localhost:#{@server_port}"
+  end
+
+  def self.up?
+    Net::HTTP.new('localhost', @server_port).head('/')
+    true
+  rescue Errno::ECONNREFUSED
+    false
+  end
+
+  private
+
+    def self.get_pid
+      `ps -eo pid,args`.split("\n").grep( /rest-assured -p #{@server_port}/ ).map{|p| p.split.first }.first
+    end
+end

data/lib/rest-assured.rb

@@ -2,14 +2,15 @@ require 'rubygems'
 require 'sinatra/base'
 require 'haml'
 require 'sass'
-#require 'sinatra/reloader'
 require 'rack-flash'
 require 'sinatra/partials'
 require 'rest-assured/init'
 require 'rest-assured/models/double'
 require 'rest-assured/models/redirect'
+require 'rest-assured/models/request'
 require 'rest-assured/routes/double'
 require 'rest-assured/routes/redirect'
+require 'rest-assured/routes/response'
 
 module RestAssured
   class Application < Sinatra::Base
@@ -46,23 +47,10 @@ module RestAssured
       scss :base
     end
 
-    %w{get post put delete}.each do |method|
-      send method, /.*/ do
-        Double.where(:fullpath => request.fullpath, :active => true, :method => method.upcase).first.try(:content) or try_redirect(request) or status 404
+    %w{get post put delete}.each do |verb|
+      send verb, /.*/ do
+        Response.perform(self)
       end
     end
-
-    #configure(:development) do
-      #register Sinatra::Reloader
-    #end
-
-    private
-      def try_redirect(request)
-        r = Redirect.ordered.find do |r|
-          request.fullpath =~ /#{r.pattern}/
-        end
-
-        r && redirect( "#{r.to}#{request.fullpath}" )
-      end
   end
 end

data/lib/rest-assured/client.rb

@@ -0,0 +1,17 @@
+module RestAssured
+  module Client
+    class Config
+      attr_reader :server_address
+
+      def server_address=(addr)
+        @server_address = Double.site = addr
+      end
+    end
+
+    def self.config
+      @config ||= Config.new
+    end
+  end
+end
+
+require 'rest-assured/client/resources'

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

@@ -0,0 +1,9 @@
+require 'active_resource'
+
+module RestAssured
+  module Client
+    class Double < ActiveResource::Base
+      self.site = RestAssured.config.server_address
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+require 'active_resource'
+require 'uri'
+
+module RestAssured::Client
+  class Double < ActiveResource::Base
+  end
+end

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

@@ -1,15 +1,17 @@
 class Double < ActiveRecord::Base
-  attr_accessible :fullpath, :content, :description, :method
+  attr_accessible :fullpath, :content, :description, :verb
 
   METHODS = %w{GET POST PUT DELETE}
 
   validates_presence_of :fullpath, :content
-  validates_inclusion_of :method, :in => METHODS
+  validates_inclusion_of :verb, :in => METHODS
 
   before_save :toggle_active
-  before_validation :set_method
+  before_validation :set_verb
   after_destroy :set_active
 
+  has_many :requests
+
   private
     def toggle_active
       ne = id ? '!=' : 'IS NOT'
@@ -19,8 +21,8 @@ class Double < ActiveRecord::Base
       end
     end
 
-    def set_method
-      self.method = 'GET' unless method.present?
+    def set_verb
+      self.verb = 'GET' unless verb.present?
     end
 
     def set_active

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

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

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

@@ -1,3 +1,5 @@
+require 'json'
+
 module RestAssured
   module DoubleRoutes
     def self.included(router)
@@ -15,9 +17,19 @@ module RestAssured
         haml :'doubles/new'
       end
 
-      router.post '/doubles' do
-        f = { :fullpath => params['fullpath'], :content => params['content'], :description => params['description'], :method => params['method'] }
-        @double = Double.create(params['double'] || f)
+      router.get '/doubles/:id.json' do |id|
+        begin
+          double = Double.find(id)
+          body double.to_json(:include => :requests)
+        rescue ActiveRecord::RecordNotFound
+          status 404
+        end
+      end
+
+      router.post /^\/doubles(\.json)?$/ do |passes_json|
+        f = { :fullpath => params['fullpath'], :content => params['content'], :description => params['description'], :verb => params['verb'] }
+
+        @double = Double.create(passes_json ? JSON.parse(request.body.read)['double'] : ( params['double'] || f )) 
 
         if browser?
           if @double.errors.blank?
@@ -29,8 +41,10 @@ module RestAssured
           end
         else
           if @double.errors.present?
-            status 400
-            body @double.errors.full_messages.join("\n")
+            status 422
+            body @double.errors.to_json
+          else
+            body @double.to_json
           end
         end
       end

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

@@ -0,0 +1,17 @@
+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
+      d.requests.create!(:rack_env => request.env.to_json, :body => body, :params => request.params.to_json)
+
+      app.body d.content
+    elsif r = Redirect.ordered.find { |r| request.fullpath =~ /#{r.pattern}/ }
+      app.redirect( "#{r.to}#{request.fullpath}" )
+    else
+      app.status 404
+    end
+  end
+end

data/lib/rest-assured/version.rb

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

data/rest-assured.gemspec

@@ -22,10 +22,10 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'sinatra', '>= 1.3.1'
   s.add_dependency 'rack-flash', '>= 0.1.2'
-  #s.add_dependency 'sinatra-reloader'
   s.add_dependency 'haml', '>= 3.1.3'
   s.add_dependency 'sass', '>= 3.1.8'
   s.add_dependency 'activerecord', '~> 3.1.0'
   s.add_dependency 'sqlite3', '>= 1.3.4'
+  s.add_dependency 'activeresource'
 end
 

data/spec/client/resource_double_spec.rb

@@ -0,0 +1,44 @@
+require 'uri'
+require File.expand_path('../../spec_helper', __FILE__)
+
+module RestAssured::Client
+  describe Double do
+    before do
+      @orig_addr = RestAssured::Client.config.server_address
+    end
+
+    after do
+      RestAssured::Client.config.server_address = @orig_addr
+    end
+
+    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'
+      ::Double.where(:id => d.id).should exist
+    end
+
+    it 'finds exising double' do
+      d = ::Double.create :fullpath => '/some/api', :content => 'content'
+
+      Double.find(d.id).id.should be d.id
+    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')
+
+      dd = Double.find(d.id)
+      dd.requests.size.should == 2
+      dd.requests.first.rack_env.should == 'rack_env json'
+      dd.requests.first.params.should == 'params'
+      dd.requests.last.body.should == 'other body'
+    end
+  end
+end

data/spec/functional/double_routes_spec.rb

@@ -2,10 +2,10 @@ require File.expand_path('../../spec_helper', __FILE__)
 
 describe 'Double routes' do
   let :test_double do
-    { :fullpath => '/api/google?a=5', :content => 'some awesome content', :method => 'POST' }
+    { :fullpath => '/api/google?a=5', :content => 'some awesome content', :verb => 'POST' }
   end
   let :valid_params do
-    { 'double[fullpath]' =>  test_double[:fullpath], 'double[content]' => test_double[:content], 'double[method]' => test_double[:method] }
+    { 'double[fullpath]' =>  test_double[:fullpath], 'double[content]' => test_double[:content], 'double[verb]' => test_double[:verb] }
   end
   let :invalid_params do
     { 'double[fullpath]' =>  test_double[:fullpath] }
@@ -102,7 +102,7 @@ describe 'Double routes' do
       post '/doubles', test_double.except(:content)
 
       last_response.should_not be_ok
-      last_response.body.should =~ /Content can't be blank/
+      last_response.body.should =~ /\{"content":\["can't be blank"\]\}/
     end
 
     it "deletes all doubles" do
@@ -114,4 +114,36 @@ describe 'Double routes' do
       Double.count.should == 0
     end
   end
+
+  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 be_ok
+      Double.exists?(test_double).should be_true
+      last_response.body.should == Double.where(test_double).first.to_json
+    end
+
+    it "reports failure when creating with invalid parameters" do
+      post '/doubles.json', { :double => test_double.except(:content) }.to_json, 'CONTENT_TYPE' => 'Application/json'
+
+      last_response.should_not be_ok
+      last_response.body.should =~ /\{"content":\["can't be blank"\]\}/
+    end
+
+    it 'loads double as AR resource' do
+      d = 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'
+      
+      last_response.status.should == 404
+    end
+  end
 end

data/spec/functional/response_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require 'rest-assured/routes/response'
+
+describe Response do
+  [:get, :post, :put, :delete].each do |verb|
+    it "processes an unknown request" do
+
+      Response.should_receive(:perform).with(an_instance_of(RestAssured::Application))
+      send verb, '/some/path'
+    end
+  end
+
+  let(:request) {
+    double('Request',
+           :request_method => 'GET',
+           :fullpath => '/api',
+           :env => stub(:to_json => 'env'),
+           :body => stub(:read => 'body').as_null_object,
+           :params => stub(:to_json => 'params')
+          )
+  }
+  let(:rest_assured_app) { double('App', :request => request).as_null_object }
+
+  it "returns double content if an active one found with the same fullpath and the same method as request" do
+    d = Double.create :fullpath => '/some/path', :content => 'content' 
+    request.stub(:fullpath).and_return(d.fullpath)
+
+    rest_assured_app.should_receive(:body).with(d.content)
+    Response.perform(rest_assured_app)
+  end
+
+  it "redirects if double not hit but there is redirect that matches request" do
+    r = Redirect.create :to => 'http://exmple.com/api', :pattern => '.*'
+    fullpath = '/some/other/path'
+    request.stub(:fullpath).and_return(fullpath)
+
+    rest_assured_app.should_receive(:redirect).with(r.to + fullpath)
+
+    Response.perform(rest_assured_app)
+  end
+
+  it "returns 404 if neither double nor redirect matches the request" do
+    rest_assured_app.should_receive(:status).with(404)
+    
+    Response.perform(rest_assured_app)
+  end
+
+  it 'records request if double matches' do
+    requests = double
+    Double.stub_chain('where.first').and_return(double(:requests => requests).as_null_object)
+
+    requests.should_receive(:create!).with(:rack_env => 'env', :body => 'body', :params => 'params')
+
+    Response.perform(rest_assured_app)
+  end
+end

data/spec/models/double_spec.rb

@@ -2,16 +2,17 @@ require File.expand_path('../../spec_helper', __FILE__)
 
 describe Double do
   let :valid_params do
-    { :fullpath => '/some/api', :content => 'some content', :method => 'GET' }
+    { :fullpath => '/some/api', :content => 'some content', :verb => 'GET' }
   end
 
   it { should validate_presence_of(:fullpath) }
   it { should validate_presence_of(:content) }
-  #it { should ensure_inclusion_of(:method).in(Double::METHODS) }
+  #it { should ensure_inclusion_of(:verb).in(Double::METHODS) }
+  it { should have_many(:requests) }
 
-  it "defaults method to GET" do
-    f = Double.create valid_params.except(:method)
-    f.method.should == 'GET'
+  it "defaults verb to GET" do
+    f = Double.create valid_params.except(:verb)
+    f.verb.should == 'GET'
   end
 
   it "makes double active by default" do

data/spec/models/request_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require 'rest-assured/models/request'
+
+describe Request do
+  it { should belong_to(:double) }
+  it { should validate_presence_of(:rack_env) }
+
+  it 'knows when it has been created' do
+    now = Time.now
+    Time.stub(:now).and_return(now)
+    r = Request.create(:body => 'sdfsd', :rack_env => 'headers')
+
+    r.created_at.should == now
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,8 @@
 require 'rubygems'
 require 'spork'
 
+$:.unshift(File.expand_path('../../lib'), __FILE__)
+
 Spork.prefork do
   require 'capybara/rspec'
   require 'rack/test'
@@ -40,10 +42,23 @@ Spork.prefork do
 end
 
 Spork.each_run do
-  require File.expand_path('../../lib/rest-assured', __FILE__)
+  require 'rest-assured'
+  require 'rest-assured/client'
   require 'shoulda-matchers'
+  require File.expand_path('../../features/support/test-server', __FILE__)
 
-  DatabaseCleaner.strategy = :truncation
+  at_exit do
+    TestServer.stop
+  end
+
+  TestServer.start(:port => 9876)
+
+  while not TestServer.up?
+    puts 'Waiting for TestServer to come up...'
+    sleep 1
+  end
+
+  RestAssured::Client.config.server_address = 'http://localhost:9876'
 
   Capybara.app = RestAssured::Application
 
@@ -51,4 +66,5 @@ Spork.each_run do
     RestAssured::Application
   end
 
+  DatabaseCleaner.strategy = :truncation
 end

metadata

@@ -1,13 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: rest-assured
 version: !ruby/object:Gem::Version 
-  hash: 19
-  prerelease: 
+  hash: 15424055
+  prerelease: 6
   segments: 
   - 0
+  - 2
+  - 0
+  - rc
   - 1
-  - 4
-  version: 0.1.4
+  version: 0.2.0.rc1
 platform: ruby
 authors: 
 - Artem Avetisyan
@@ -15,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-10 00:00:00 Z
+date: 2011-10-17 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sinatra
@@ -113,6 +115,20 @@ dependencies:
         version: 1.3.4
   type: :runtime
   version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: activeresource
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id007
 description: 
 email: 
 - artem.avetisyan@bbc.co.uk
@@ -140,25 +156,35 @@ files:
 - db/migrate/20110823132023_add_method_to_fixtures.rb
 - db/migrate/20110912162948_rename_url_to_fullpath.rb
 - db/migrate/20110912163705_rename_fixtures_to_doubles.rb
+- db/migrate/20111013122857_create_requests.rb
+- db/migrate/20111016174101_rename_method_to_verb.rb
+- features/call_history.feature
 - features/doubles_via_api.feature
 - features/doubles_via_ui.feature
 - features/persistence.feature
 - features/redirect_rules_via_api.feature
 - features/redirect_rules_via_ui.feature
+- features/step_definitions/call_history_steps.rb
 - features/step_definitions/doubles_steps.rb
 - features/step_definitions/persistence_steps.rb
 - features/step_definitions/redirect_rules_steps.rb
 - features/step_definitions/support/numeric_transforms.rb
 - features/support/env.rb
 - features/support/selenium-fix.rb
+- features/support/test-server.rb
 - lib/active_record/leak_connection_patch.rb
 - lib/rest-assured.rb
+- lib/rest-assured/client.rb
+- lib/rest-assured/client/double.rb
+- lib/rest-assured/client/resources.rb
 - lib/rest-assured/config.rb
 - lib/rest-assured/init.rb
 - lib/rest-assured/models/double.rb
 - lib/rest-assured/models/redirect.rb
+- lib/rest-assured/models/request.rb
 - lib/rest-assured/routes/double.rb
 - lib/rest-assured/routes/redirect.rb
+- lib/rest-assured/routes/response.rb
 - lib/rest-assured/version.rb
 - lib/sinatra/partials.rb
 - public/css/grid.inuit.css
@@ -177,10 +203,13 @@ files:
 - public/javascript/application.js
 - public/javascript/jquery.jgrowl_minimized.js
 - rest-assured.gemspec
+- spec/client/resource_double_spec.rb
 - spec/functional/double_routes_spec.rb
 - spec/functional/redirect_routes_spec.rb
+- spec/functional/response_spec.rb
 - spec/models/double_spec.rb
 - spec/models/redirect_spec.rb
+- spec/models/request_spec.rb
 - spec/spec_helper.rb
 - views/base.scss
 - views/doubles/_form.haml
@@ -214,12 +243,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: rest-assured
@@ -228,19 +259,25 @@ signing_key:
 specification_version: 3
 summary: A tool for high level mocking/stubbing HTTP based REST services
 test_files: 
+- features/call_history.feature
 - features/doubles_via_api.feature
 - features/doubles_via_ui.feature
 - features/persistence.feature
 - features/redirect_rules_via_api.feature
 - features/redirect_rules_via_ui.feature
+- features/step_definitions/call_history_steps.rb
 - features/step_definitions/doubles_steps.rb
 - features/step_definitions/persistence_steps.rb
 - features/step_definitions/redirect_rules_steps.rb
 - features/step_definitions/support/numeric_transforms.rb
 - features/support/env.rb
 - features/support/selenium-fix.rb
+- features/support/test-server.rb
+- spec/client/resource_double_spec.rb
 - spec/functional/double_routes_spec.rb
 - spec/functional/redirect_routes_spec.rb
+- spec/functional/response_spec.rb
 - spec/models/double_spec.rb
 - spec/models/redirect_spec.rb
+- spec/models/request_spec.rb
 - spec/spec_helper.rb