rest-assured 0.2.0 → 0.3.0

data/Gemfile

@@ -17,7 +17,11 @@ gem 'launchy'
 gem 'rake'
 gem "spork", "> 0.9.0.rc"
 gem "guard-spork"
-gem 'rb-fsevent' if RUBY_PLATFORM =~ /darwin/
+if RUBY_PLATFORM =~ /darwin/
+  gem 'growl_notify'
+  gem 'rb-fsevent'
+end
 gem 'sinatra-activerecord'
 gem 'mysql'
 gem 'sqlite3', '~> 1.3.4'
+gem 'thin'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rest-assured (0.2.0)
+    rest-assured (0.3.0)
       activerecord (~> 3.1.0)
       activeresource (~> 3.1.0)
       haml (>= 3.1.3)
@@ -11,21 +11,22 @@ PATH
 GEM
   remote: http://rubygems.org/
   specs:
-    activemodel (3.1.1)
-      activesupport (= 3.1.1)
+    activemodel (3.1.3)
+      activesupport (= 3.1.3)
       builder (~> 3.0.0)
       i18n (~> 0.6)
-    activerecord (3.1.1)
-      activemodel (= 3.1.1)
-      activesupport (= 3.1.1)
+    activerecord (3.1.3)
+      activemodel (= 3.1.3)
+      activesupport (= 3.1.3)
       arel (~> 2.2.1)
       tzinfo (~> 0.3.29)
-    activeresource (3.1.1)
-      activemodel (= 3.1.1)
-      activesupport (= 3.1.1)
-    activesupport (3.1.1)
+    activeresource (3.1.3)
+      activemodel (= 3.1.3)
+      activesupport (= 3.1.3)
+    activesupport (3.1.3)
       multi_json (~> 1.0)
     addressable (2.2.6)
+    archive-tar-minitar (0.5.2)
     arel (2.2.1)
     awesome_print (0.4.0)
     builder (3.0.0)
@@ -40,18 +41,22 @@ GEM
       capybara (~> 1.0)
     childprocess (0.2.2)
       ffi (~> 1.0.6)
-    columnize (0.3.4)
+    columnize (0.3.5)
     cucumber (1.1.0)
       builder (>= 2.1.2)
       diff-lcs (>= 1.1.2)
       gherkin (~> 2.5.0)
       json (>= 1.4.6)
       term-ansicolor (>= 1.0.6)
+    daemons (1.1.4)
     database_cleaner (0.6.7)
     diff-lcs (1.1.3)
-    ffi (1.0.9)
+    eventmachine (0.12.10)
+    ffi (1.0.11)
     gherkin (2.5.4)
       json (>= 1.4.6)
+    growl_notify (0.0.3)
+      rb-appscript
     guard (0.8.8)
       thor (~> 0.14.6)
     guard-spork (0.3.1)
@@ -65,10 +70,10 @@ GEM
     json_pure (1.6.1)
     launchy (2.0.5)
       addressable (~> 2.2.6)
-    linecache (0.46)
-      rbx-require-relative (> 0.0.4)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
     mime-types (1.16)
-    multi_json (1.0.3)
+    multi_json (1.0.4)
     mysql (2.8.1)
     nokogiri (1.5.0)
     rack (1.3.5)
@@ -79,8 +84,8 @@ GEM
     rack-test (0.6.1)
       rack (>= 1.0)
     rake (0.9.2.2)
+    rb-appscript (0.6.1)
     rb-fsevent (0.4.3.1)
-    rbx-require-relative (0.0.5)
     rspec (2.7.0)
       rspec-core (~> 2.7.0)
       rspec-expectations (~> 2.7.0)
@@ -89,15 +94,20 @@ GEM
     rspec-expectations (2.7.0)
       diff-lcs (~> 1.1.2)
     rspec-mocks (2.7.0)
-    ruby-debug (0.10.4)
-      columnize (>= 0.1)
-      ruby-debug-base (~> 0.10.4.0)
-    ruby-debug-base (0.10.4)
-      linecache (>= 0.3)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
     rubyzip (0.9.4)
-    selenium-webdriver (2.9.1)
+    selenium-webdriver (2.12.2)
       childprocess (>= 0.2.1)
-      ffi (= 1.0.9)
+      ffi (~> 1.0.9)
       json_pure
       rubyzip
     shoulda-matchers (1.0.0.beta3)
@@ -111,6 +121,10 @@ GEM
     spork (0.9.0.rc9)
     sqlite3 (1.3.4)
     term-ansicolor (1.0.7)
+    thin (1.3.1)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
     thor (0.14.6)
     tilt (1.3.3)
     tzinfo (0.3.31)
@@ -126,6 +140,7 @@ DEPENDENCIES
   capybara-firebug
   cucumber
   database_cleaner
+  growl_notify
   guard-spork
   interactive_editor
   launchy
@@ -135,8 +150,9 @@ DEPENDENCIES
   rb-fsevent
   rest-assured!
   rspec
-  ruby-debug
+  ruby-debug19
   shoulda-matchers
   sinatra-activerecord
   spork (> 0.9.0.rc)
   sqlite3 (~> 1.3.4)
+  thin

data/README.markdown

@@ -15,9 +15,13 @@ You are going to need ruby >= 1.8.7.
 
 First make sure there is database adapter:
 
-    bash$ gem install mysql # or sqlite
+    bash$ gem install sqlite3 # or mysql
 
-If using mysql, rest-assured expects database 'rest\_assured' to be accessible by user 'root' with no password. Those are defaults and are changeable with command line options.
+If using mysql, rest-assured expects database 'rest\_assured' to be accessible by user 'root' with no password. Those are defaults and can be changed with cli options.
+
+It is also recommended to have thin installed. This improves startup time (over default webrick) and also it works in-memory sqlite (which webrick does not):
+
+    bash$ gem install thin
 
 Then install gem and run:
 
@@ -28,23 +32,21 @@ Or clone from github and run:
 
     bash$ git clone git@github.com:BBC/rest-assured.git
     bash$ cd rest-assured && bundle install
-    bash$ ./bin/rest-assured -a mysql &
+    bash$ ./bin/rest-assured -d :memory: & # in-memory sqlite db
 
-This starts an instance of rest-assured on port 4578 (changable with --port option). You can now access it via REST or web interfaces on 'http://localhost:4578'
+This starts an instance of rest-assured on port 4578. It is accessible via REST or web interfaces on 'http://localhost:4578'
 
 Various options (such as ssl, port, db credentials, etc.) are available through command line options. Check out `rest-assured -h` to see what they are.
 
-NOTE that although sqlite is an option, I found it locking under any non-trivial load. Mysql feels much more reliable. But may be that is me sqliting it wrong.
-
-## REST API
+NOTE that although sqlite is an extremely handy option (especially with :memory:), I found it sometimes locking tables under non-trivial load. Hence there is mysql - more setup, but always works. But may be that is just me sqliting it wrong.
 
-### Doubles
+## Doubles
 
-Double is a stub/mock of a particular external call.
+Double is a stub/mock of HTTP request.
 
-#### Ruby Client API
+### Ruby Client API
 
-Rest-assured provides client library which partially implements ActiveResource (create and get). To make it available put the following in your test setup code (e.g. env.rb)
+Rest-assured provides client library to work with doubles. Set it up in env.rb/spec_helper.rb first:
 
 ```ruby
 require 'rest-assured/client'
@@ -52,107 +54,127 @@ require 'rest-assured/client'
 RestAssured::Client.config.server_address = 'http://localhost:4578' # or wherever your rest-assured is
 ```
 
-You can then create doubles in your tests
+You can then create doubles in your tests:
 
 ```ruby
 RestAssured::Double.create(fullpath: '/products', content: 'this is content')
 ```
 
-Or, in case you need verifications, create double in a Given part
+Now GET 'http://localhost:4578/products' will be returning 'this is content'.
+
+You can also verify what requests happen on a double. Say this is a Given part of a test:
 
 ```ruby
 @double = RestAssured::Double.create(fullpath: '/products', verb: 'POST')
 ```
 
-And verify requests happened on that double in a Then part
+Then let us assume that 'http://localhost:4578/products' got POSTed as a result of some actions in When part. Now we can examine requests happened on that double in Then part:
 
 ```ruby
-@double.wait_for_requests(1, :timeout => 10) # default timeout 5 seconds
+@double.wait_for_requests(1, :timeout => 10) # defaults to 5 seconds
 
 req = @double.requests.first
 
 req.body.should == expected_payload
 JSON.parse(req.params).should == expected_params_hash
-JSON.parse(req.rack_env)['ACCEPT'].should == 'Application/json'
+JSON.parse(req.rack_env)['ACCEPT'].should == 'text/html'
 ```
 
-#### Plain REST API
+Use plain rest api to clear doubles/redirects between tests:
+
+```ruby
+RestClient.delete "#{RestAssured::Client.config.server_address}/redirects/all"
+RestClient.delete "#{RestAssured::Client.config.server_address}/doubles/all"
+```
+
+### Plain REST API
+
+#### Create double
 
-##### Create double 
-  HTTP POST to '/doubles.json' creates double and returns its json representation.
+  HTTP POST to '/doubles' creates double and returns its json representation.
   The following options can be passed as request 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. Optional.
   - __verb__ - one of http the following http verbs: GET, POST, PUT, DELETE. Optional. GET is default.
   - __status__ - status returned when double is requested. Optional. 200 is default.
-
-  Example (using ruby RestClient):
+  - __response_headers__ - key/value map of headers. Optional.
   
-```ruby
-response = RestClient.post 'http://localhost:4578/doubles', { fullpath: '/api/v2/products?type=fresh', verb: 'GET', content: 'this is list of products', status: 200 }
-puts response.body
-```
-  Produces:
+  Example:
 
-    "{\"double\":{\"fullpath\":\"/api/v2/products?type=fresh\",\"verb\":\"GET\",\"id\":123,\"content\":\"this is list of products\",\"description\":null,\"status\":null,\"active\":true}}"
+    bash$ curl -d 'fullpath=/api/something&content=awesome&response_headers%5BContent-Type%5D=text%2Fhtml' http://localhost:4578/doubles
+    {"double":{"active":true,"content":"awesome","description":null,"fullpath":"/api/something","id":1,"response_headers":{"Content-Type":"text/html"},"status":200,"verb":"GET"}}
 
-  And then GETting 'http://localhost:4578/api/v2/products?type=fresh' (in browser for instance) should return "this is list of products".
+    bash$ curl http://localhost:4578/api/something
+    awesome
 
   If there is more than one double for the same fullpath and verb, the last created one gets served. In UI you can manually control which double is 'active' (gets served).
 
-##### Get double state
-  HTTP GET to '/double/:id.json' returns json with double current state. Use id from create json as :id.
-
-  Example (using ruby RestClient):
-
-```ruby
-response = RestClient.get 'http://localhost:4578/doubles/123.json'
-puts response.body
-```
-
-  Assuming the above double has been requested once, this call would produce
+#### Get double state
 
-    "{\"double\":{\"fullpath\":\"/api/v2/products?type=fresh\",\"verb\":\"GET\",\"id\":123,\"requests\":[{\"rack_env\":\"LOOK FOR YOUR HEADERS HERE\",\"created_at\":\"2011-11-07T18:34:21+00:00\",\"body\":\"\",\"params\":\"{}\"}],\"content\":\"this is list of products\",\"description\":null,\"status\":null,\"active\":true}}"
-
-  The important bit here is 'requests' array. This is history of requests for that double (in chronological order). Each element contains the following data (keys):
+  HTTP GET to '/doubles/:id.json' returns json with double current state. Use id from create json as :id.
+  
+  Example:
+    
+    bash$ curl http://localhost:4578/doubles/1.json | prettify_json.rb
+    {
+        "double": {
+            "verb": "GET",
+            "fullpath": "/api/something",
+            "response_headers": {
+                "Content-Type": "text/html"
+            },
+            "id": 1,
+            "requests": [
+            {
+                "double_id": 1,
+                "created_at": "2011-12-12T11:13:33+00:00",
+                "body": "",
+                "rack_env": "{\"SERVER_SOFTWARE\":\"thin 1.3.1 codename Triple Espresso\",\"SERVER_NAME\":\"localhost\",\"rack.version\":[1,0],\"rack.multithread\":false,\"rack.multiprocess\":false,\"rack.run_once\":false,\"REQUEST_METHOD\":\"GET\",\"REQUEST_PATH\":\"/api/something\",\"PATH_INFO\":\"/api/something\",\"REQUEST_URI\":\"/api/something\",\"HTTP_VERSION\":\"HTTP/1.1\",\"HTTP_USER_AGENT\":\"curl/7.19.7 (universal-apple-darwin10.0) libcurl/7.19.7 OpenSSL/0.9.8l zlib/1.2.3\",\"HTTP_HOST\":\"localhost:4578\",\"HTTP_ACCEPT\":\"*/*\",\"GATEWAY_INTERFACE\":\"CGI/1.2\",\"SERVER_PORT\":\"4578\",\"QUERY_STRING\":\"\",\"SERVER_PROTOCOL\":\"HTTP/1.1\",\"rack.url_scheme\":\"http\",\"SCRIPT_NAME\":\"\",\"REMOTE_ADDR\":\"127.0.0.1\",\"async.callback\":{},\"async.close\":{},\"rack.session\":{\"session_id\":\"2d206d4edb880d41ae098bf0551c6904a4914f8632d101606b5304d4f651ce52\",\"tracking\":{\"HTTP_USER_AGENT\":\"06e79511d71287ca292dced4ef07c8fff9400376\",\"HTTP_ACCEPT_ENCODING\":\"da39a3ee5e6b4b0d3255bfef95601890afd80709\",\"HTTP_ACCEPT_LANGUAGE\":\"da39a3ee5e6b4b0d3255bfef95601890afd80709\"},\"__FLASH__\":{}},\"rack.session.options\":{\"key\":\"rack.session\",\"path\":\"/\",\"domain\":null,\"expire_after\":null,\"secure\":false,\"httponly\":true,\"defer\":false,\"renew\":false,\"sidbits\":128,\"secure_random\":{\"pid\":7885},\"secret\":\"bf80c75d713c92d2e3f94ea58be318c3f8988a3ed79d997f9cf883cc7aab1141225477ed81da7fe62ac77ecac3f979d255328dcbe8caa1bb342f4be6cb850983\",\"coder\":{},\"id\":\"2d206d4edb880d41ae098bf0551c6904a4914f8632d101606b5304d4f651ce52\"},\"rack.request.cookie_hash\":{},\"rack.session.unpacked_cookie_data\":{\"session_id\":\"2d206d4edb880d41ae098bf0551c6904a4914f8632d101606b5304d4f651ce52\"},\"x-rack.flash\":{\"opts\":{\"sweep\":true},\"store\":{\"session_id\":\"2d206d4edb880d41ae098bf0551c6904a4914f8632d101606b5304d4f651ce52\",\"tracking\":{\"HTTP_USER_AGENT\":\"06e79511d71287ca292dced4ef07c8fff9400376\",\"HTTP_ACCEPT_ENCODING\":\"da39a3ee5e6b4b0d3255bfef95601890afd80709\",\"HTTP_ACCEPT_LANGUAGE\":\"da39a3ee5e6b4b0d3255bfef95601890afd80709\"},\"__FLASH__\":{}},\"flagged\":[]},\"rack.request.query_string\":\"\",\"rack.request.query_hash\":{}}",
+                "id": 1,
+                "params": "{}"
+            }
+            ],
+            "content": "awesome",
+            "description": null,
+            "status": 200,
+            "active": true
+        }
+    }
+
+  The above assumes that that double has been requested once. Request history is in "requests" array (in chronological order). Each element contains the following data (keys):
   
   - __body__ - request payload
-  - __params__ - request parameters
+  - __params__ - request parameters. json
   - __created_at__ - request timestamp
-  - __rack_env__ - raw request dump (key value pairs). Including request headers
+  - __rack_env__ - raw request dump (json) including request headers
+
+#### Delete all doubles
 
-##### Delete all doubles
   HTTP DELETE to '/doubles/all' deletes all doubles. Useful for cleaning up between tests.
 
-### Redirects
+## Redirects
 
 It is sometimes desirable to only double certain calls while letting others through to the 'real' services. Meet Redirects. Kind of "rewrite rules" for requests that didn't match any double. Here is the rest API for managing redirects:
 
-#### Create redirect
+### Create redirect
+
   HTTP POST to '/redirects' creates redirect.
   The following options can be passed as request parameters:
 
   - __pattern__ - regex (perl5 style) tested against request fullpath. Mandatory
   - __to__ - url base e.g., 'https://myserver:8787/api'. Mandatory
 
-  Example (using ruby RestClient):
-
-```ruby
-RestClient.post 'http://localhost:4578/redirects', { pattern: '^/auth', to: 'https://myserver.com/api' }
-```
+  Example:
+  
+    bash$ curl -d 'pattern=^/auth&to=https://myserver.com/api' http://localhost:4578/redirects
 
   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.
 
-#### Delete all redirects
-  HTTP DELETE to '/redirects/all' deletes all redirects. Useful for cleaning up between tests.
-
-## TODO
+### Delete all redirects
 
-* Hide wiring rest-assured into ruby project behind client api
-* Bring UI upto date with rest-api (add verbs, statuses, request history)
-* Add custom response headers
+  HTTP DELETE to '/redirects/all' deletes all redirects. Useful for cleaning up between tests.
 
 ## Author
 
@@ -160,11 +182,19 @@ RestClient.post 'http://localhost:4578/redirects', { pattern: '^/auth', to: 'htt
 
 ## Changelog
 
-0.2
-  - adds verifications
-  - adds ruby client
-  - adds custom return statuses
-  - adds ssl
-  - adds mysql support
-0.1 initial public release
+#### 0.3 (12 Dec 2011)
+
+* you can now specify response headers for double to respond with
+
+#### 0.2
+
+* adds verifications
+* adds ruby client
+* adds custom return statuses
+* adds ssl
+* adds mysql support
+
+#### 0.1
+
+* initial public release
 

data/db/migrate/20111208155906_add_response_headers_to_doubles.rb

@@ -0,0 +1,9 @@
+class AddResponseHeadersToDoubles < ActiveRecord::Migration
+  def self.up
+    add_column :doubles, :response_headers, :string
+  end
+
+  def self.down
+    remove_column :doubles, :response_headers
+  end
+end

data/features/rest_api/doubles.feature

@@ -16,6 +16,11 @@ Feature: use doubles via api
       | /api/some?a=3&b=dd | more content |        | GET         |        | 200           |
       | /api/empty         |              | POST   | POST        |        | 200           |
 
+  @now
+  Scenario: view created double details
+    When I create a double
+    Then I should be able to get json representation of that double from response
+
   Scenario Outline: request fullpath that matches double
     Given there is double with "<fullpath>" as fullpath, "<content>" as response content, "<verb>" as request verb and "<status>" as status
     When I "<verb>" "<fullpath>"

data/features/ruby_api/create_double.feature

@@ -0,0 +1,40 @@
+Feature: create double using ruby client api
+  As ruby developer
+  I want to be able to create doubles via client api
+  So that interactions with rest-assured server are completely hidden from me
+
+  Background:
+    Given rest-assured is running locally:
+    """
+    RestAssured::Client.config.server_address = 'http://localhost:9876'
+    """
+
+  Scenario: create double with defaults
+    When I create a double:
+    """
+    @double = RestAssured::Double.create(:fullpath => '/some/api')
+    """
+    Then it should have the following defaults:
+    """
+    @double.verb.should             == 'GET'
+    @double.response_headers.should == {}
+    @double.status.should           == 200
+    @double.content.should          == nil
+
+    get @double.fullpath
+    last_response.should be_ok
+    """
+
+  Scenario: create double with specified response headers
+    When I create a double:
+    """
+    @double = RestAssured::Double.create(:fullpath => '/some/api', :response_headers => { 'Content-Type' => 'text/html' })
+    """
+    Then it should have the following defaults:
+    """
+    @double.response_headers.should == { 'Content-Type' => 'text/html' }
+
+    get @double.fullpath
+    last_response.headers['Content-Type'].should == 'text/html'
+    """
+

data/features/ruby_api/verify_requests.feature

@@ -1,15 +1,49 @@
-Feature: check double's call history
-  In order to verify outcomes of my app that take form of http requests
+Feature: verify requests that happened on double
+  In order to check that my app is performing correct requests
   As test developer
   I want to be able to get double 'call history' 
 
+  Background:
+    Given rest-assured is running locally:
+    """
+    RestAssured::Client.config.server_address = 'http://localhost:9876'
+    """
+
   Scenario: no calls made to double
-    Given there is a double
-    When I request call history for that double
-    Then it should be empty
+    Given I created a double:
+    """
+    @double = RestAssured::Double.create(:fullpath => '/some/api')
+    """
+    When I request call history for that double:
+    """
+    @requests = @double.reload.requests
+    """
+    Then it should be empty:
+    """
+    @requests.should be_empty
+    """
 
   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
+    Given I created a double:
+    """
+    @double = RestAssured::Double.create(:fullpath => '/some/path', :content => 'some content', :verb => 'POST')
+    """
+    When that double gets requested:
+    """
+    post @double.fullpath, { :foo => 'bar' }.to_json, "CONTENT_TYPE" => "application/json"
+    post @double.fullpath, { :fooz => 'baaz'}, 'SOME_HEADER' => 'header_data'
+    """
+    And I request call history for that double:
+    """
+    @requests = @double.reload.requests
+    """
+    Then I should see history records for those requests:
+    """
+    @requests.first.body.should == { :foo => 'bar' }.to_json
+    @requests.first.params.should == '{}'
+    JSON.parse( @requests.first.rack_env )["CONTENT_TYPE"].should == 'application/json'
+
+    @requests.last.body.should == 'fooz=baaz'
+    JSON.parse( @requests.last.params ).should == { 'fooz' => 'baaz' }
+    JSON.parse( @requests.last.rack_env )["SOME_HEADER"].should == 'header_data'
+    """

data/features/ruby_api/wait_for_requests.feature

@@ -4,7 +4,11 @@ Feature: wait for requests on double to happen
   I want to be able to wait until specified number of requests happen
 
   Background:
-    Given I created a double:
+    Given rest-assured is running locally:
+    """
+    RestAssured::Client.config.server_address = 'http://localhost:9876'
+    """
+    And I created a double:
     """
     @double = RestAssured::Double.create(:fullpath => '/some/api')
     """
@@ -29,7 +33,6 @@ Feature: wait for requests on double to happen
     Expected 3 requests. Got 2.
     """
 
-  @now
   Scenario: custom timeout
     When I wait for 3 requests:
     """

data/features/step_definitions/doubles_steps.rb

@@ -4,22 +4,23 @@ Given /^there are no doubles$/ do
   RestAssured::Models::Double.destroy_all
 end
 
-When /^I create a double with "([^"]*)" as fullpath and "([^"]*)" as response content$/ do |fullpath, content|
-  post '/doubles', { :fullpath => fullpath, :content => content }
-  last_response.should be_ok
-end
-
 When /^I create a double with "([^""]*)" as fullpath, "([^""]*)" as response content, "([^""]*)" as request verb and status as "([^""]*)"$/ do |fullpath, content, verb, status|
   post '/doubles', { :fullpath => fullpath, :content => content, :verb => verb, :status => status }
   last_response.should be_ok
 end
 
-Then /^I should get (#{CAPTURE_A_NUMBER}) in response status$/ do |status|
-  last_response.status.should == status
+When /^I create a double$/ do
+  post '/doubles', { :fullpath => '/api/something' }
+  @create_a_double_response = last_response.body
+end
+
+Then /^I should be able to get json representation of that double from response$/ do
+  d = RestAssured::Models::Double.last
+  JSON.parse( @create_a_double_response ).should == JSON.parse( d.to_json )
 end
 
-Then /^there should be (#{CAPTURE_A_NUMBER}) double with "([^"]*)" as fullpath and "([^"]*)" as response content$/ do |n, fullpath, content|
-  RestAssured::Models::Double.where(:fullpath => fullpath, :content => content).count.should == n
+Then /^I should get (#{CAPTURE_A_NUMBER}) in response status$/ do |status|
+  last_response.status.should == status
 end
 
 Then /^there should be (#{CAPTURE_A_NUMBER}) double with "([^""]*)" as fullpath, "([^""]*)" as response content, "([^""]*)" as request verb and status as "(#{CAPTURE_A_NUMBER})"$/ do |n, fullpath, content, verb, status|
@@ -34,11 +35,6 @@ Given /^there is double with "([^"]*)" as fullpath, "([^"]*)" as response conten
   RestAssured::Models::Double.create(:fullpath => fullpath, :content => content, :verb => verb, :status => status)
 end
 
-Given /^I register "([^"]*)" as fullpath and "([^"]*)" as response content$/ do |fullpath, content|
-  post '/doubles', { :fullpath => fullpath, :content => content }
-  last_response.should be_ok
-end
-
 When /^I request "([^"]*)"$/ do |fullpath|
   get fullpath
 end

data/features/step_definitions/redirect_rules_steps.rb

@@ -1,7 +1,3 @@
-Given /^there are no redirect rules$/ do
-  RestAssured::Models::Redirect.destroy_all
-end
-
 Then /^I should get (\d+)$/ do |code|
   last_response.status.should.to_s == code
 end

data/features/step_definitions/ruby_api_steps.rb

@@ -1,29 +1,24 @@
-Given /^there is a double$/ do
-  @double = RestAssured::Double.create(:fullpath => '/some/path', :content => 'some content', :verb => 'POST')
+Given /^rest\-assured is running locally:$/ do |code|
+  eval code
 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'
+When /^that double gets requested:$/ do |code|
+  eval code
 end
 
-When /^I request call history for that double$/ do
-  @requests = @double.reload.requests
+When /^I request call history for that double:$/ do |code|
+  eval code
 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'
+Then /^I should see history records for those requests:$/ do |code|
+  eval code
 end
 
-Then /^it should be empty$/ do
-  @requests.size.should == 0
+Then /^it should be empty:$/ do |code|
+  eval code
 end
 
-Given /^I created a double:$/ do |string|
+Given /^I created? a double:$/ do |string|
   # expected string is:
   # @double = RestAssured::Double.create(:fullpath => '/some/api', :verb => 'POST')
   eval string
@@ -67,3 +62,7 @@ Then /^it should raise MoreRequestsExpected error after with the following messa
   @more_reqs_exc.should be_instance_of RestAssured::MoreRequestsExpected
   @more_reqs_exc.message.should =~ /#{string}/
 end
+
+Then /^it should have the following defaults:$/ do |code|
+  eval code
+end

data/features/support/env.rb

@@ -57,8 +57,6 @@ Spork.each_run do
     sleep 1
   end
 
-  RestAssured::Client.config.server_address = 'http://localhost:9876'
-
   def app
     RestAssured::Application
   end

data/lib/rest-assured.rb

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'sinatra/base'
 require 'sinatra/handler_options_patch'
 require 'haml'

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

@@ -4,6 +4,10 @@ module RestAssured
   class MoreRequestsExpected < StandardError; end
 
   class Double < ActiveResource::Base
+    def response_headers
+      attributes[:response_headers].attributes
+    end
+
     def wait_for_requests(n, opts = {})
       timeout = opts[:timeout] || 5
 

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

@@ -3,7 +3,9 @@ require 'net/http'
 module RestAssured
   module Models
     class Double < ActiveRecord::Base
-      attr_accessible :fullpath, :content, :description, :verb, :status
+      attr_accessible :fullpath, :content, :description, :verb, :status, :response_headers
+
+      serialize :response_headers, Hash
 
       VERBS = %w{GET POST PUT DELETE}
       STATUSES = Net::HTTPResponse::CODE_TO_OBJ.keys.map(&:to_i)
@@ -20,28 +22,29 @@ module RestAssured
       has_many :requests, :dependent => :destroy
 
       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
+        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
+          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
 end

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

@@ -26,10 +26,22 @@ module RestAssured
         end
       end
 
-      router.post /^\/doubles(\.json)?$/ do |passes_json|
-        f = { :fullpath => params['fullpath'], :content => params['content'], :description => params['description'], :verb => params['verb'], :status => params['status'] }
+      router.post /^\/doubles(\.json)?$/ do
+        begin
+          data = request.body.read
+          d = JSON.parse(data)['double']
+        rescue
+          d = params['double'] || {
+            :fullpath               => params['fullpath'],
+            :content                => params['content'],
+            :description            => params['description'],
+            :verb                   => params['verb'],
+            :status                 => params['status']
+          }
+          d.merge!(:response_headers => params['response_headers']) if params['response_headers']
+        end
 
-        @double = Models::Double.create(passes_json ? JSON.parse(request.body.read)['double'] : ( params['double'] || f )) 
+        @double = Models::Double.create(d) 
 
         if browser?
           if @double.errors.blank?

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

@@ -10,6 +10,7 @@ module RestAssured
 
         d.requests.create!(:rack_env => env.to_json, :body => body, :params => request.params.to_json)
 
+        app.headers d.response_headers
         app.body d.content
         app.status d.status
       elsif r = Models::Redirect.ordered.find { |r| request.fullpath =~ /#{r.pattern}/ }

data/lib/rest-assured/version.rb

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

data/spec/functional/double_routes_spec.rb

@@ -3,11 +3,27 @@ require File.expand_path('../../spec_helper', __FILE__)
 module RestAssured
   describe 'Double routes' do
     let :test_double do
-      { :fullpath => '/api/google?a=5', :content => 'some awesome content', :verb => 'POST', :status => '201' }
+      {
+        :fullpath         => '/api/google?a=5',
+        :content          => 'some awesome content',
+        :verb             => 'POST',
+        :status           => '201',
+        :response_headers => { 'ACCEPT' => 'text/html' }
+      }
     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] }
+      params = {
+        'double[fullpath]'         => test_double[:fullpath],
+        'double[content]'          => test_double[:content],
+        'double[verb]'             => test_double[:verb],
+        'double[status]'           => test_double[:status],
+        'double[response_headers]' => test_double[:response_headers]
+      }
+
+      params
     end
+
     let :invalid_params do
       valid_params.except('double[fullpath]')
     end
@@ -40,7 +56,9 @@ module RestAssured
 
         last_request.fullpath.should == '/doubles'
         last_response.body.should =~ /Double created/
-        Models::Double.exists?(test_double).should be true
+
+        d = Models::Double.where(test_double.except(:response_headers)).first
+        d.response_headers['ACCEPT'].should == 'text/html'
       end
 
       it "reports failure when creating with invalid parameters" do
@@ -87,7 +105,7 @@ module RestAssured
         last_response.should be_ok
         last_response.body.should =~ /Double deleted/
 
-        Models::Double.exists?(test_double).should be_false
+        Models::Double.exists?(test_double.except(:response_headers)).should be_false
       end
     end
 
@@ -96,7 +114,9 @@ module RestAssured
         post '/doubles', test_double
 
         last_response.should be_ok
-        Models::Double.exists?(test_double).should be_true
+
+        d = Models::Double.where(test_double.except(:response_headers)).first
+        d.response_headers['ACCEPT'].should == 'text/html'
       end
 
       it "reports failure when creating with invalid parameters" do
@@ -121,8 +141,10 @@ module RestAssured
         post '/doubles.json', { :double => test_double }.to_json, 'CONTENT_TYPE' => 'Application/json'
 
         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
+
+        d = Models::Double.where(test_double.except(:response_headers)).first
+        d.response_headers['ACCEPT'].should == 'text/html'
+        last_response.body.should == d.to_json
       end
 
       it "reports failure when creating with invalid parameters" do

data/spec/functional/response_spec.rb

@@ -25,7 +25,12 @@ module RestAssured
 
     context 'when double matches request' do
       before do
-        @double = Models::Double.create :fullpath => '/some/path', :content => 'content', :status => 201
+        @double = Models::Double.create \
+          :fullpath         => '/some/path',
+          :content          => 'content',
+          :response_headers => { 'ACCEPT' => 'text/html' },
+          :status           => 201
+
         request.stub(:fullpath).and_return(@double.fullpath)
       end
 
@@ -41,6 +46,12 @@ module RestAssured
         Response.perform(rest_assured_app)
       end
 
+      it 'sets response headers to those in Double#response_headers' do
+        rest_assured_app.should_receive(:headers).with(@double.response_headers)
+
+        Response.perform(rest_assured_app)
+      end
+
       it 'records request' do
         requests = double
         Models::Double.stub_chain('where.first').and_return(double(:requests => requests).as_null_object)

data/spec/models/double_spec.rb

@@ -3,7 +3,13 @@ require File.expand_path('../../spec_helper', __FILE__)
 module RestAssured::Models
   describe Double do
     let :valid_params do
-      { :fullpath => '/some/api', :content => 'some content', :verb => 'GET', :status => '303' }
+      {
+        :fullpath         => '/some/api',
+        :content          => 'some content',
+        :verb             => 'GET',
+        :status           => '303',
+        :response_headers => { 'ACCEPT' => 'text/html' }
+      }
     end
 
     it { should validate_presence_of(:fullpath) }
@@ -13,6 +19,7 @@ module RestAssured::Models
     it { should allow_mass_assignment_of(:content) }
     it { should allow_mass_assignment_of(:verb) }
     it { should allow_mass_assignment_of(:status) }
+    it { should allow_mass_assignment_of(:response_headers) }
 
     it { should have_many(:requests) }
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rest-assured
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: 
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Artem Avetisyan
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-14 00:00:00 Z
+date: 2011-12-12 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sinatra
@@ -128,9 +128,11 @@ files:
 - db/migrate/20111013122857_create_requests.rb
 - db/migrate/20111016174101_rename_method_to_verb.rb
 - db/migrate/20111021113953_add_status_to_doubles.rb
+- db/migrate/20111208155906_add_response_headers_to_doubles.rb
 - features/command_line_options.feature
 - features/rest_api/doubles.feature
 - features/rest_api/redirects.feature
+- features/ruby_api/create_double.feature
 - features/ruby_api/verify_requests.feature
 - features/ruby_api/wait_for_requests.feature
 - features/step_definitions/command_line_options_steps.rb
@@ -235,6 +237,7 @@ test_files:
 - features/command_line_options.feature
 - features/rest_api/doubles.feature
 - features/rest_api/redirects.feature
+- features/ruby_api/create_double.feature
 - features/ruby_api/verify_requests.feature
 - features/ruby_api/wait_for_requests.feature
 - features/step_definitions/command_line_options_steps.rb
@@ -258,3 +261,4 @@ test_files:
 - spec/models/redirect_spec.rb
 - spec/models/request_spec.rb
 - spec/spec_helper.rb
+has_rdoc: