mirage 3.0.0.alpha.11 → 3.0.0.alpha.12

data/features/client/start.feature

@@ -18,7 +18,7 @@ Feature: The client API can be used to start Mirage.
     """
     Mirage.start
     """
-    Then mirage should be running on 'http://localhost:7001/mirage'
+    Then mirage should be running on 'http://localhost:7001'
 
 
   Scenario: Starting Mirage on a custom port
@@ -26,7 +26,7 @@ Feature: The client API can be used to start Mirage.
     """
     Mirage.start :port => 9001
     """
-    Then mirage should be running on 'http://localhost:9001/mirage'
+    Then mirage should be running on 'http://localhost:9001'
 
 
   Scenario: Specifying a custom templates directory.
@@ -40,5 +40,5 @@ Feature: The client API can be used to start Mirage.
     """
     Mirage.start :defaults => './custom_responses_location'
     """
-    And GET is sent to 'http://localhost:7001/mirage/responses/greeting'
+    And GET is sent to '/responses/greeting'
     Then 'hello' should be returned

data/features/client/stop.feature

@@ -14,7 +14,7 @@ Feature:The client API can be used to stop instances of Mirage running on localh
     """
     Mirage.stop
     """
-    Then Connection should be refused to 'http://localhost:7001/mirage'
+    Then Connection should be refused to 'http://localhost:7001'
 
 
   Scenario: Stopping Mirage on custom port
@@ -23,7 +23,7 @@ Feature:The client API can be used to stop instances of Mirage running on localh
     """
     Mirage.stop :port => 9001
     """
-    Then mirage should not be running on 'http://localhost:9001/mirage'
+    Then mirage should not be running on 'http://localhost:9001'
 
   Scenario: Stopping multiple instances of Mirage
     Given I run 'mirage start -p 7001'
@@ -33,9 +33,9 @@ Feature:The client API can be used to stop instances of Mirage running on localh
     """
     Mirage.stop :port => [9001,10001]
     """
-    Then mirage should be running on 'http://localhost:7001/mirage'
-    Then mirage should not be running on 'http://localhost:9001/mirage'
-    Then mirage should not be running on 'http://localhost:10001/mirage'
+    Then mirage should be running on 'http://localhost:7001'
+    Then mirage should not be running on 'http://localhost:9001'
+    Then mirage should not be running on 'http://localhost:10001'
 
 
   Scenario: Stopping all instances of Mirage
@@ -46,6 +46,6 @@ Feature:The client API can be used to stop instances of Mirage running on localh
     """
     Mirage.stop :all
     """
-    Then mirage should not be running on 'http://localhost:7001/mirage'
-    Then mirage should not be running on 'http://localhost:9001/mirage'
-    Then mirage should not be running on 'http://localhost:10001/mirage'
+    Then mirage should not be running on 'http://localhost:7001'
+    Then mirage should not be running on 'http://localhost:9001'
+    Then mirage should not be running on 'http://localhost:10001'

data/features/commandline_interface/help.feature

@@ -0,0 +1,17 @@
+@command_line
+Feature: Help
+  Mirage is started from the command line. Mirage logs to mirage.log at the path where Mirage is started from.
+
+
+  Background: Mirage usage
+    Given usage information:
+    """
+      mirage help [TASK]  # Describe available tasks or one specific task
+      mirage start        # Starts mirage
+      mirage stop         # Stops mirage
+    """
+
+
+  Scenario: Starting with help option
+    Given I run 'mirage help'
+    Then the usage information should be displayed

data/features/commandline_interface/readme.md

@@ -0,0 +1 @@
+Mirage has a fully functional commandline interface check it out!

data/features/{server/commandline_interface → commandline_interface}/start.feature

@@ -1,6 +1,6 @@
 @command_line
-Feature: Mirage is started from the command line.
-  more than instance of Mirage can be started on different ports at the same time.
+Feature: Starting Mirage
+  Mirage is started from the command line. more than instance of Mirage can be started on different ports at the same time.
 
   By default mirage runs on port 7001.
 
@@ -8,11 +8,11 @@ Feature: Mirage is started from the command line.
   Scenario: Starting mirage
     Given Mirage is not running
     When I run 'mirage start'
-    Then mirage should be running on 'http://localhost:7001/mirage'
+    Then mirage should be running on 'http://localhost:7001'
     And 'mirage.log' should exist
 
 
   Scenario: Starting Mirage on a custom port
     Given Mirage is not running
     When I run 'mirage start -p 9001'
-    Then mirage should be running on 'http://localhost:9001/mirage'
+    Then mirage should be running on 'http://localhost:9001'

data/features/{server/commandline_interface → commandline_interface}/stop.feature

@@ -1,44 +1,42 @@
 @command_line
-Feature: Mirage can be stopped from the commandline
+Feature: Stopping Mirage
+  Mirage can be stopped from the commandline
   If more than one instance of Mirage is running, you will be asked to supply the ports which represent the running instances
   of mirage that you wish to stop.
 
-  Scenario: Stopping a single instance
+  Scenario: Stopping a single instance of Mirage
     Given I run 'mirage start -p 7001'
     When I run 'mirage stop'
-    Then mirage should not be running on 'http://localhost:7001/mirage'
+    Then mirage should not be running on 'http://localhost:7001'
 
-
-  Scenario: Calling stop when there is more than one instance running
-    Given I run 'mirage start -p 7001'
-    Given I run 'mirage start -p 9001'
-    When I run 'mirage stop'
-    Then I should see 'Mirage is running on ports 7001, 9001. Please run mirage stop -p [PORT(s)] instead' on the command line
-    And mirage should be running on 'http://localhost:7001/mirage'
-    And mirage should be running on 'http://localhost:9001/mirage'
-
-
-  Scenario: stopping on a single instance using the port
+  Scenario: Stopping an instance running on a given port
     Given I run 'mirage start -p 7001'
     And I run 'mirage start -p 9001'
     When I run 'mirage stop -p 7001'
-    Then mirage should be running on 'http://localhost:9001/mirage'
-    Then mirage should not be running on 'http://localhost:7001/mirage'
+    Then mirage should be running on 'http://localhost:9001'
+    Then mirage should not be running on 'http://localhost:7001'
 
-  Scenario: stop more than one instance
+  Scenario: Stopping more than one instance
     Given I run 'mirage start -p 7001'
     And I run 'mirage start -p 9001'
     And I run 'mirage start -p 10001'
     When I run 'mirage stop -p 7001 9001'
-    Then mirage should be running on 'http://localhost:10001/mirage'
-    Then mirage should not be running on 'http://localhost:7001/mirage'
-    Then mirage should not be running on 'http://localhost:9001/mirage'
+    Then mirage should be running on 'http://localhost:10001'
+    Then mirage should not be running on 'http://localhost:7001'
+    Then mirage should not be running on 'http://localhost:9001'
 
-  Scenario: stop all instances
+  Scenario: Stopping all running instances
     Given I run 'mirage start -p 7001'
     And I run 'mirage start -p 9001'
     When I run 'mirage stop -p all'
-    Then mirage should not be running on 'http://localhost:10001/mirage'
-    Then mirage should not be running on 'http://localhost:7001/mirage'
-    Then mirage should not be running on 'http://localhost:9001/mirage'
+    Then mirage should not be running on 'http://localhost:10001'
+    Then mirage should not be running on 'http://localhost:7001'
+    Then mirage should not be running on 'http://localhost:9001'
 
+  Scenario: Calling stop when there is more than one instance running
+    Given I run 'mirage start -p 7001'
+    Given I run 'mirage start -p 9001'
+    When I run 'mirage stop'
+    Then I should see 'Mirage is running on ports 7001, 9001. Please run mirage stop -p [PORT(s)] instead' on the command line
+    And mirage should be running on 'http://localhost:7001'
+    And mirage should be running on 'http://localhost:9001'

data/features/{server/logging.feature → logging.feature}

@@ -2,5 +2,5 @@ Feature: Output from Mirage is stored in mirage.log.
   This file is located at the root from which mirage is started.
 
   Scenario: Mirage logs request
-    Given GET is sent to 'http://localhost:7001/mirage/templates/greeting'
-    Then mirage.log should contain '/mirage/templates/greeting'
+    Given GET is sent to '/templates/greeting'
+    Then mirage.log should contain '/templates/greeting'

data/features/{server/prime.feature → prime.feature}

@@ -1,6 +1,7 @@
 #TODO - rename responses directory to templates
 @command_line
-Feature: Mirage can be primed with a set of templates.
+Feature: Preloading templates
+  Mirage can be primed with a set of templates.
   By default, Mirage loads any .rb files found in ./responses on startup. Mirage can also be made to load responses from a directory
   of your choosing by using the -d/--defaults option
 
@@ -17,7 +18,7 @@ Feature: Mirage can be primed with a set of templates.
     end
     """
     And I run 'mirage start'
-    When GET is sent to 'http://localhost:7001/mirage/responses/greeting'
+    When GET is sent to '/responses/greeting'
     Then 'hello' should be returned
 
 
@@ -30,5 +31,5 @@ Feature: Mirage can be primed with a set of templates.
     end
     """
     And I run 'mirage start --defaults /tmp/responses'
-    And GET is sent to 'http://localhost:7001/mirage/responses/greeting'
+    And GET is sent to '/responses/greeting'
     Then 'hello' should be returned

data/features/readme.md

@@ -0,0 +1,7 @@
+Mirage in an open source project that can be used to mock HTTP services. It facilitates application development in environments where external systems aren't easily accessed or can't be made to behave in a repeatable way.
+
+At its core, Mirage is a web application with a restful interface that can be configured with responses. The descriptors for these response are called [Templates](/lashd/mirage/docs/templates).
+
+If you're using Ruby then Mirage has a [client](/lashd/mirage/docs/client) to get you going straight away.
+
+If you're using another language, then the interface to Mirage is simple and it would be great to see clients emerging other languages too. If you need any help please ask! :)

data/features/requests/delete.feature

@@ -0,0 +1,48 @@
+Feature: Deleting tracked requests
+  Tracked request data can be deleted
+
+  Background: The MockServer has already got a response for greeting and leaving on it.
+    Given the following template template:
+    """
+      {
+         "response":{
+            "body":"Hello"
+         }
+      }
+    """
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to '/templates/greeting'
+
+    Given the following template template:
+    """
+      {
+         "response":{
+            "body":"Goodbye"
+         }
+      }
+    """
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to '/templates/leaving'
+
+
+    And GET is sent to '/responses/greeting'
+    And GET is sent to '/responses/leaving'
+
+    
+  Scenario: Deleting all requests
+    And DELETE is sent to '/requests'
+
+    When GET is sent to '/requests/1'
+    Then a 404 should be returned
+    When GET is sent to '/requests/2'
+    Then a 404 should be returned
+
+
+
+  Scenario: Deleting a stored request for a particular response
+    And DELETE is sent to '/requests/1'
+
+    When GET is sent to '/requests/1'
+    Then a 404 should be returned
+    When GET is sent to '/requests/2'
+    Then a 200 should be returned

data/features/{server/requests → requests}/get.feature

@@ -1,4 +1,5 @@
-Feature: After a response has been served from Mirage, the request that triggered it can be retrieved. This is useful
+Feature: Checking tracked requests
+  After a response has been served from Mirage, the request that triggered it can be retrieved. This is useful
   for testing that the correct information was sent by your application code.
 
   Use a template's ID to retrieve the last request that was last received.
@@ -17,19 +18,19 @@ Feature: After a response has been served from Mirage, the request that triggere
       }
     """
     And 'response.body' is base64 encoded
-    And the template is sent using PUT to 'http://localhost:7001/mirage/templates/greeting'
+    And the template is sent using PUT to '/templates/greeting'
 
 
   Scenario: Getting request data when the data was in the body.
-    Given I send POST to 'http://localhost:7001/mirage/responses/greeting' with request entity
+    Given I send POST to '/responses/greeting' with request entity
     """
     Hello Mirage
     """
-    When GET is sent to 'http://localhost:7001/mirage/requests/1'
+    When GET is sent to '/requests/1'
     Then request data should have been retrieved
 
 
   Scenario: Getting request data for a template that has not yet served a response.
-    Given GET is sent to 'http://localhost:7001/mirage/requests/1'
+    Given GET is sent to '/requests/1'
     Then a 404 should be returned
 

data/features/{server/save_and_revert.feature → save_and_revert.feature}

@@ -13,11 +13,11 @@ Feature: Having set up the Mirage with a number of defaults, your tests may cont
       }
     """
     And 'response.body' is base64 encoded
-    And the template is sent using PUT to 'http://localhost:7001/mirage/templates/greeting'
+    And the template is sent using PUT to '/templates/greeting'
 
     
   Scenario: Saving Mirage and reverting it
-    Given PUT is sent to 'http://localhost:7001/mirage/backup'
+    Given PUT is sent to '/backup'
     And the following template template:
     """
       {
@@ -27,9 +27,9 @@ Feature: Having set up the Mirage with a number of defaults, your tests may cont
       }
     """
     And 'response.body' is base64 encoded
-    And the template is sent using PUT to 'http://localhost:7001/mirage/templates/greeting'
+    And the template is sent using PUT to '/templates/greeting'
     
-    When PUT is sent to 'http://localhost:7001/mirage'
-    And GET is sent to 'http://localhost:7001/mirage/responses/greeting'
+    When PUT is sent to '/'
+    And GET is sent to '/responses/greeting'
 
     Then 'The default greeting' should be returned

data/features/step_definitions/my_steps.rb

@@ -66,11 +66,11 @@ Given /^the file '(.*)' contains:$/ do |file_path, content|
 end
 
 Then /^the usage information should be displayed$/ do
-  @usage.each { |line| @commandline_output.should include(line) }
+  @usage.each_line { |line| @commandline_output.should include(line) }
 end
 
-Given /^usage information:$/ do |table|
-  @usage = table.raw.flatten.collect { |line| normalise(line) }
+Given /^usage information:$/ do |usage|
+  @usage = normalise(usage.to_s)
 end
 
 Then /^I run$/ do |text|
@@ -88,8 +88,8 @@ Given /^the following gems are required to run the Mirage client test code:$/ do
   @code_snippet = text.gsub("\"", "\\\\\"")
 end
 
-When /^I send (POST|PUT) to '(http:\/\/localhost:7001\/mirage\/(.*?))' with request entity$/ do |method, url, endpoint, entity|
-
+When /^I send (POST|PUT) to '(.*)' with request entity$/ do |method, endpoint, entity|
+  url = "http://localhost:7001#{endpoint}"
   @response = case method
                 when 'POST'
                 then
@@ -100,8 +100,9 @@ When /^I send (POST|PUT) to '(http:\/\/localhost:7001\/mirage\/(.*?))' with requ
               end
 end
 
-When /^(GET|PUT|POST|OPTIONS|HEAD|DELETE) is sent to '(http:\/\/localhost:\d{4}\/mirage([^']*))'$/ do |method, url, endpoint|
+When /^(GET|PUT|POST|OPTIONS|HEAD|DELETE) is sent to '([^']*)'$/ do |method, endpoint|
   start_time = Time.now
+  url = "http://localhost:7001#{endpoint}"
   @response = case method
                 when 'GET' then
                   http_get(url)
@@ -120,7 +121,8 @@ When /^(GET|PUT|POST|OPTIONS|HEAD|DELETE) is sent to '(http:\/\/localhost:\d{4}\
 end
 
 
-When /^I send (PUT|POST) to '(http:\/\/localhost:7001\/mirage\/([^']*))' with body:$/ do |method, url, endpoint, body|
+When /^I send (PUT|POST) to '(.*)' with body '(.*)'$/ do |method, endpoint, body|
+  url = "http://localhost:7001#{endpoint}"
   start_time = Time.now
   @response = case method
                 when 'PUT'
@@ -132,7 +134,8 @@ When /^I send (PUT|POST) to '(http:\/\/localhost:7001\/mirage\/([^']*))' with bo
   @response_time = Time.now - start_time
 end
 
-When /^I send PUT to '(http:\/\/localhost:7001\/mirage\/([^']*))' with body '([^']*)' and headers:$/ do |url, endpoint, body, table|
+When /^I send PUT to '(.*)' with body '([^']*)' and headers:$/ do |endpoint, body, table|
+  url = "http://localhost:7001#{endpoint}"
   headers = {}
   table.raw.each do |row|
     parameter, value = row[0], row[1]
@@ -166,8 +169,10 @@ When /^I click '(.*)'$/ do |thing|
   @page = @page.links.find { |link| link.attributes['id'] == thing }.click
 end
 
-When /^I send (GET|POST) to '(http:\/\/localhost:7001\/mirage\/(.*?))' with parameters:$/ do |http_method, url, endpoint, table|
+When /^I send (GET|POST) to '(.*)' with parameters:$/ do |http_method, endpoint, table|
+
 
+  url = "http://localhost:7001#{endpoint}"
   parameters = {}
   table.raw.each do |row|
     parameter, value = row[0].to_sym, row[1]
@@ -199,7 +204,8 @@ Given /^I send PUT to '(http:\/\/localhost:7001\/mirage\/(.*?))' with file: ([^'
   end
 end
 
-Given /^I send PUT to '(http:\/\/localhost:7001\/mirage\/(.*?))' with body '([^']*)' and parameters:$/ do |url, endpoint, body, table|
+Given /^I send PUT to '(.*?)' with body '([^']*)' and parameters:$/ do |endpoint, body, table|
+  url = "http://localhost:7001#{endpoint}"
   headers = {}
   table.raw.each do |row|
     parameter, value = row[0], row[1]
@@ -227,8 +233,9 @@ end
 When /^'(.*)' is base64 encoded$/ do |template_component|
   @response_template.send(:eval, "#{template_component}=Base64.encode64(#{template_component})")
 end
-When /^the template is sent using PUT to '(http:\/\/localhost:7001\/mirage\/(.*?))'$/ do |url, endpoint|
-  @response = http_put(url, @response_template.to_hash.to_json, :headers => {"Content-Type" => "application/json"})
+When /^the template is sent using PUT to '(.*?)'$/ do |endpoint|
+
+  @response = http_put("http://localhost:7001#{endpoint}", @response_template.to_hash.to_json, :headers => {"Content-Type" => "application/json"})
 end
 Given /^a template for '(.*)' has been set with a value of '(.*)'$/ do |endpoint, value|
   $mirage.templates.put(endpoint, value)
@@ -240,4 +247,32 @@ Then /^request data should have been retrieved$/ do
   request_data.include?('headers').should == true
   request_data.include?('body').should == true
   request_data.include?('request_url').should == true
+end
+Given(/^the following Template JSON:$/) do |text|
+  @response_template = Hashie::Mash.new(JSON.parse(text))
+end
+Then(/^the template (request|response) specification should have the following set:$/) do |spec, table|
+  template_json = JSON.parse(http_get("http://localhost:7001/templates/#{JSON.parse(@response.body)['id']}").body)
+  request_specification = template_json[spec]
+  request_specification.size.should==table.hashes.size
+  table.hashes.each do |hash|
+    default = request_specification[hash['Setting'].downcase.gsub(' ', '_')]
+    case required_default = hash['Default']
+      when 'none'
+        case default
+          when Array
+            default.should == []
+          when Hash
+            default.should == {}
+          else
+            default.should == ""
+
+        end
+      else
+        default.to_s.downcase.should == required_default.downcase
+    end
+  end
+end
+Then(/^the following json should be returned:$/) do |text|
+  JSON.parse(text).should == JSON.parse(@response.body)
 end