rest-assured 0.3.2 → 1.0.0.rc1

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -3,6 +3,7 @@ source "http://rubygems.org"
 # Specify your gem's dependencies in rest-assured.gemspec
 gemspec
 
+gem 'awesome_print'
 gem 'cucumber'
 gem 'database_cleaner'
 gem 'rspec'
@@ -12,6 +13,7 @@ gem 'capybara'
 gem 'capybara-firebug'
 gem 'rake'
 gem 'mysql2'
+gem 'sqlite3'
 gem 'thin'
 gem 'relish'
 gem "spork", "> 0.9.0.rc"
@@ -25,8 +27,9 @@ group :local do
   gem 'launchy'
   gem "guard-spork"
   if RUBY_PLATFORM =~ /darwin/
-    gem 'growl_notify'
+    gem 'growl'
     gem 'rb-fsevent'
+    gem 'rb-readline'
   end
   gem 'sinatra-activerecord'
 end

data/README.markdown

@@ -19,7 +19,7 @@ Rest-assured requires a database to run. Either sqlite or mysql. So, make sure t
 
     bash$ gem install sqlite3 # or mysql2
 
-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.
+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 with in-memory sqlite (which webrick does not):
 
@@ -36,11 +36,11 @@ Or clone from github and run:
     bash$ cd rest-assured && bundle install
     bash$ ./bin/rest-assured -d :memory: & # in-memory sqlite db
 
-This starts up an instance of rest-assured on port 4578. It is accessible via REST or web interfaces on 'http://localhost:4578'
+This starts up 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 extremely handy option (especially with :memory:), I found it sometimes locking tables under non-trivial load. Hence there is a Plan B - mysql. But may be that is just me sqliting it wrong.
+NOTE that although sqlite is an extremely handy option (especially with `-d :memory:`), I found it sometimes locking tables under non-trivial load. Hence there is a Plan B - mysql. But may be that is just me sqliting it wrong.
 
 ## Doubles
 
@@ -50,21 +50,29 @@ Double is a stub/spy of HTTP request. Create a double that has the same request
 
 Rest-assured provides client library to work with doubles. Check out 'Ruby API' section in [documentation](https://www.relishapp.com/artemave/rest-assured) for full reference.
 
-Set it up first in env.rb/spec_helper.rb:
+Start up the server:
 
 ```ruby
-require 'rest-assured/client'
+# env.rb/spec_helper.rb
+require 'rest-assured'
 
-RestAssured::Client.config.server_address = 'http://localhost:4578' # or wherever your rest-assured is
+RestAssured::Server.start(database: ':memory:', port: 7899) # or any other option available on command line
 ```
+This server will be automatically shut down when your tests are done.
 
-You can then create doubles in your tests:
+Alternatively, if you want to use existing server instance:
+
+```ruby
+RestAssured::Server.address = 'http://localhost:4578' # or wherever it is
+```
+
+You can now create doubles in your tests:
 
 ```ruby
 RestAssured::Double.create(fullpath: '/products', content: 'this is content')
 ```
 
-Now GET 'http://localhost:4578/products' will be returning 'this is content'.
+Now GET `http://localhost:4578/products` will be returning `this is content`.
 
 You can also verify what requests happen on a double, or, in other words, spy on a double. Say this is a Given part of a test:
 
@@ -72,7 +80,7 @@ You can also verify what requests happen on a double, or, in other words, spy on
 @double = RestAssured::Double.create(fullpath: '/products', verb: 'POST')
 ```
 
-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:
+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) # defaults to 5 seconds
@@ -87,8 +95,8 @@ JSON.parse(req.rack_env)['ACCEPT'].should == 'text/html'
 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"
+RestClient.delete "#{RestAssured::Server.address}/redirects/all"
+RestClient.delete "#{RestAssured::Server.address}/doubles/all"
 ```
 
 ### Plain REST API
@@ -97,13 +105,13 @@ For those using rest-assured from non-ruby environments.
 
 #### Create double
 
-  HTTP POST to '/doubles' creates a double and returns its json representation.
+  HTTP POST to `/doubles` creates a 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.
+  - __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.
+  - __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.
   - __response_headers__ - key/value map of headers. Optional.
   
   Example:
@@ -118,7 +126,7 @@ For those using rest-assured from non-ruby environments.
 
 #### Get double state
 
-  HTTP GET to '/doubles/:id.json' returns json with double current state. Use id from create json as :id.
+  HTTP GET to `/doubles/:id.json` returns json with double current state. Use id from create json as `:id`.
   
   Example:
     
@@ -148,7 +156,7 @@ For those using rest-assured from non-ruby environments.
         }
     }
 
-  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):
+  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. json
@@ -157,34 +165,34 @@ For those using rest-assured from non-ruby environments.
 
 #### Delete all doubles
 
-  HTTP DELETE to '/doubles/all' deletes all doubles. Useful for cleaning up between tests.
+  HTTP DELETE to `/doubles/all` deletes all doubles. Useful for cleaning up between tests.
 
 ## 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. 
+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. 
 
-Another potential use for redirects is setting up a 'default' double that matches multiple fullpaths. This is of course given your app does not mind an extra redirect. Also note that 'default' double still covers only one http verb so requests with different methods won't match.
+Another potential use for redirects is setting up a "default" double that matches multiple fullpaths. This is of course given your app does not mind an extra redirect. Also note that such "default" double still only covers single http verb so requests with different methods won't match (hint: need an extra double).
 
 Here is the rest API for managing redirects:
 
 ### Create redirect
 
-  HTTP POST to '/redirects' creates 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
+  - __pattern__ - regex (perl5 style) tested against request fullpath. e.g, `^/auth/(.*)`. Mandatory
+  - __to__ - url base e.g, `http://example.com/api/\1?p=1` where `\1` is a reference to captured group from the pattern. Mandatory
 
   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.
+  Now request (any verb) to `http://localhost:4578/auth/services/1` will get redirected to `https://myserver.com/api/`. Provided of course there is no double matched for that fullpath and verb. Captured group in pattern can be referenced from replacement e.g. `\1`, `\2`, etc.
   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.
+  HTTP DELETE to `/redirects/all` deletes all redirects. Useful for cleaning up between tests.
 
 ## Author
 
@@ -192,6 +200,20 @@ Here is the rest API for managing redirects:
 
 ## Changelog
 
+#### 1.0.0.rc1 (13 Feb 2012)
+
+* start/stop rest-assured via api
+* redirects support pattern/replacement
+
+#### 0.3.2 (23 Jan 2012)
+
+* double 'activeness' does not take verb into account (bugfix)
+
+#### 0.3.1 (09 Jan 2012)
+
+* lock rack version to <= 1.3.6 until they release fix for
+https://github.com/rack/rack/issues/299
+
 #### 0.3 (12 Dec 2011)
 
 * you can now specify response headers for double to respond with

data/bin/rest-assured

@@ -51,8 +51,8 @@ OptionParser.new do |opts|
     user_opts[:logfile] = logfile
   end
 
-  opts.on('--ssl', "Whether or not to run on https. Defaults to false (http)") do |use_ssl|
-    user_opts[:use_ssl] = true
+  opts.on('--ssl', "Whether or not to run on https. Defaults to false (http)") do
+    user_opts[:ssl] = true
   end
 
   opts.on('-c', '--ssl_cert FILENAME', "Path to ssl_cert. Defaults to self signed certificate shipped with rest-assured") do |ssl_cert|
@@ -71,5 +71,5 @@ end.parse!
 
 RestAssured::Config.build(user_opts)
 
-require 'rest-assured'
+require 'rest-assured/application'
 RestAssured::Application.run!

data/features/command_line_options.feature

@@ -54,10 +54,10 @@ Feature: command line options
 
   Scenario Outline: use ssl option
     When I start rest-assured with <option>
-    Then rest-assured should "<use_ssl>"
+    Then rest-assured should "<ssl>"
 
     Examples:
-      | option | use_ssl |
+      | option | ssl |
       |        | false   |
       | --ssl  | true    |
 

data/features/rest_api/redirects.feature

@@ -1,3 +1,4 @@
+@now
 Feature: manage redirect rules
   In order to be able to mock only part of api
   As a developer
@@ -10,21 +11,21 @@ Feature: manage redirect rules
 
   Scenario: add redirect rule
     Given blank slate
-    When I register redirect with pattern "^/api" and uri "http://real.api.co.uk"
+    When I create redirect from "^/api/(.*)" to "http://example.com/\1"
     And I request "/api/something"
-    Then it should redirect to "http://real.api.co.uk/api/something"
+    Then it should redirect to "http://example.com/something"
 
   Scenario: add second redirect that match the same request
-    Given there is redirect with pattern "/api/something" and uri "http://real.api.co.uk"
-    When I register redirect with pattern "/api/some.*" and uri "http://real.com"
+    Given there is redirect from "/api/something" to "http://example.com"
+    When I create redirect from "/api/some.*" to "http://real.com"
     And I request "/api/something"
-    Then it should redirect to "http://real.api.co.uk/api/something"
+    Then it should redirect to "http://example.com/"
 
   Scenario: add second redirect that does not match the same request
-    Given there is redirect with pattern "/api/something" and uri "http://real.api.co.uk"
-    When I register redirect with pattern "/api/some" and uri "http://real.com"
-    And I request "/api/someth"
-    Then it should redirect to "http://real.com/api/someth"
+    Given there is redirect from "/api/thing" to "http://real.com"
+    When I create redirect from "/api/some.*" to "http://example.com"
+    And I request "/api/something"
+    Then it should redirect to "http://example.com/"
 
   Scenario: clear redirects
     Given there are some redirects

data/features/ruby_api/create_double.feature

@@ -1,14 +1,9 @@
+@ruby_api
 Feature: create double
   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: default options
     When I create a double:
     """

data/features/ruby_api/test_server.feature

@@ -0,0 +1,42 @@
+Feature: test server
+  In order to have easy integration with my test code
+  As a ruby developer
+  I want to have a client library take care of starting/stopping an instance of rest-assured appropriately
+
+  Scenario: start rest-assured server
+    Given there is free tcp port
+    When I start rest-assured server via client library:
+    """
+    RestAssured::Server.start(:port => @free_tcp_port)
+    """
+    Then rest-assured server should be running:
+    """
+    RestAssured::Server.should be_up
+    """
+
+  Scenario: start asyncronously (so that other heavy setup - e.g. firefox startup - can be done in parallel)
+    Given there is free tcp port
+    When I start rest-assured asyncronously:
+    """
+    RestAssured::Server.start!(:port => @free_tcp_port)
+    """
+    Then rest-assured server should not be running:
+    """
+    RestAssured::Server.should_not be_up
+    """
+    When it finally comes up
+    Then rest-assured server should be running:
+    """
+    RestAssured::Server.should be_up
+    """
+
+  Scenario: stop rest-assured server
+    Given rest-assured has been started via client library
+    When I stop it:
+    """
+    RestAssured::Server.stop
+    """
+    Then it should be stopped:
+    """
+    RestAssured::Server.should_not be_up
+    """

data/features/ruby_api/verify_requests.feature

@@ -1,14 +1,9 @@
+@ruby_api
 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 I created a double:
     """

data/features/ruby_api/wait_for_requests.feature

@@ -1,14 +1,11 @@
+@ruby_api
 Feature: wait for requests on double to happen
   In order to know when it is a good time to verify requests on a double
   As test developer
   I want to be able to wait until specified number of requests happen
 
   Background:
-    Given rest-assured is running locally:
-    """
-    RestAssured::Client.config.server_address = 'http://localhost:9876'
-    """
-    And I created a double:
+    Given I created a double:
     """
     @double = RestAssured::Double.create(:fullpath => '/some/api')
     """

data/features/step_definitions/command_line_options_steps.rb

@@ -41,5 +41,5 @@ Then /^ssl certificate used should be "([^"]*)" and ssl key should be "([^"]*)"$
 end
 
 Then /^rest\-assured should "([^"]*)"$/ do |use|
-  @app_config[:use_ssl].to_s.should == use
+  @app_config[:ssl].to_s.should == use
 end

data/features/step_definitions/doubles_steps.rb

@@ -39,6 +39,10 @@ When /^I request "([^"]*)"$/ do |fullpath|
   get fullpath
 end
 
+When /sleep (\d+)/ do |n|
+  sleep n
+end
+
 When /^I "([^"]*)" "([^"]*)"$/ do |verb, fullpath|
   send(verb.downcase, fullpath)
 end

data/features/step_definitions/redirect_rules_steps.rb

@@ -2,18 +2,14 @@ Then /^I should get (\d+)$/ do |code|
   last_response.status.should.to_s == code
 end
 
-Given /^there is redirect with pattern "([^"]*)" and uri "([^"]*)"$/ do |pattern, url|
+When /^(?:I create|there is) redirect from "([^"]*)" to "([^"]*)"$/ 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|
-  step %{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
+  last_request.url.should == real_api_url
 end
 
 Given /^the following redirects exist:$/ do |redirects|

data/features/step_definitions/ruby_api_steps.rb

@@ -66,3 +66,48 @@ end
 Then /^the following should be true:$/ do |code|
   eval code
 end
+
+Given /^there is free tcp port$/ do
+  @free_tcp_port = RestAssured::Utils::PortExplorer.free_port
+end
+
+When /^I start rest-assured server via client library:$/ do |code|
+  eval code
+end
+
+Then /^rest\-assured server should be running:$/ do |code|
+  eval code
+end
+
+When /^I start rest\-assured asyncronously:$/ do |code|
+  eval code
+end
+
+Then /^rest\-assured server should not be running:$/ do |code|
+  eval code
+end
+
+When /^it finally comes up$/ do
+  timeout(5) do
+    loop do
+      begin
+        Net::HTTP.new('localhost', @free_tcp_port).head('/')
+        break
+      rescue Errno::ECONNREFUSED
+        sleep 1
+      end
+    end
+  end
+end
+
+Given /^rest\-assured has been started via client library$/ do
+  RestAssured::Server.start(:port => RestAssured::Utils::PortExplorer.free_port)
+end
+
+When /^I stop it:$/ do |code|
+  eval code
+end
+
+Then /^it should be stopped:$/ do |code|
+  eval code
+end