mirage 2.4.2 → 3.0.0.alpha.1

data/features/server/commandline_interface/start.feature

@@ -2,6 +2,8 @@
 Feature: 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.
+
 
   Scenario: Starting mirage
     Given Mirage is not running
@@ -14,17 +16,3 @@ Feature: Mirage is started from the command line.
     Given Mirage is not running
     When I run 'mirage start -p 9001'
     Then mirage should be running on 'http://localhost:9001/mirage'
-
-
-  Scenario: Starting multiple instances of Mirage
-    Given Mirage is not running
-    When I run 'mirage start -p 7001'
-    And I run 'mirage start -p 9001'
-    Then mirage should be running on 'http://localhost:7001/mirage'
-    And mirage should be running on 'http://localhost:9001/mirage'
-
-
-  Scenario: Starting Mirage when it is already running
-    Given Mirage is running
-    When I run 'mirage start -p 7001'
-    Then I should see 'Mirage is already running' on the command line

data/features/server/commandline_interface/stop.feature

@@ -1,13 +1,15 @@
 @command_line
-Feature: stop
+Feature: 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: Calling stop without specifying the port when only one instance is running
+  Scenario: Stopping a single instance
     Given I run 'mirage start -p 7001'
     When I run 'mirage stop'
     Then mirage should not be running on 'http://localhost:7001/mirage'
 
 
-  Scenario: Calling stop without specifying the port when more than one instance is running
+  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'
@@ -16,7 +18,7 @@ Feature: stop
     And mirage should be running on 'http://localhost:9001/mirage'
 
 
-  Scenario: stopping on a single instance
+  Scenario: stopping on a single instance using the port
     Given I run 'mirage start -p 7001'
     And I run 'mirage start -p 9001'
     When I run 'mirage stop -p 7001'

data/features/server/logging.feature

@@ -1,6 +1,6 @@
 Feature: Output from Mirage is stored in mirage.log.
   This file is located at the root from which mirage is started.
 
-  Scenario: response is set.
-    Given I send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'Hello'
+  Scenario: Mirage logs request
+    Given GET is sent to 'http://localhost:7001/mirage/templates/greeting'
     Then mirage.log should contain '/mirage/templates/greeting'

data/features/server/prime.feature

@@ -1,89 +1,34 @@
+#TODO - rename responses directory to templates
 @command_line
-Feature: Mirage can be primed with a set of responses.
-  By default, Mirage loads any rb files found in ./responses on startup. Mirage can also be made to load response for a directory
-  of your choosing
+Feature: 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
 
   Responses can be added to the responses directory and used to prime Mirage after Mirage has been started.
 
-  Priming mirage causes any modifications to its state to be lost
+  Priming causes any modifications to Mirage's current state to be lost.
 
 
-  Scenario: Mirage is started with the responses to be used for priming located in ./responses
+  Scenario: Using the default responses directory
     Given the file 'responses/default_greetings.rb' contains:
     """
     prime do |mirage|
-      mirage.put('greeting', 'hello')
-      mirage.put('leaving', 'goodbye')
+      mirage.templates.put('greeting', 'hello')
     end
     """
     And I run 'mirage start'
-    When I send GET to 'http://localhost:7001/mirage/responses/greeting'
+    When GET is sent to 'http://localhost:7001/mirage/responses/greeting'
     Then 'hello' should be returned
-    When I send GET to 'http://localhost:7001/mirage/responses/leaving'
-    Then 'goodbye' should be returned
 
 
-  Scenario: Mirage is started pointing with a relative path given for the responses directory
-    Given the file './custom_responses_location/default_greetings.rb' contains:
-    """
-    prime do |mirage|
-      mirage.put('greeting', 'hello')
-    end
-    """
-    And I run 'mirage start -d ./custom_responses_location'
-    When I send GET to 'http://localhost:7001/mirage/responses/greeting'
-    Then 'hello' should be returned
-
-
-  Scenario: Mirage is started pointing with a full path for the responses
+  Scenario: Using a custom responses directory
     Given Mirage is not running
     And the file '/tmp/responses/default_greetings.rb' contains:
     """
     prime do |mirage|
-      mirage.put('greeting', 'hello')
+      mirage.templates.put('greeting', 'hello')
     end
     """
     And I run 'mirage start --defaults /tmp/responses'
-    When I send PUT to 'http://localhost:7001/mirage/defaults'
-    And I send GET to 'http://localhost:7001/mirage/responses/greeting'
+    And GET is sent to 'http://localhost:7001/mirage/responses/greeting'
     Then 'hello' should be returned
-
-
-  Scenario: Priming mirage after its state has been modified
-    Given the file 'responses/default_greetings.rb' contains:
-    """
-    prime do |mirage|
-      mirage.put('greeting', 'hello')
-    end
-    """
-    And I run 'mirage start'
-    And I send DELETE to 'http://localhost:7001/mirage/templates'
-    And I send PUT to 'http://localhost:7001/mirage/templates/a_new_response' with request entity
-    """
-    new response
-    """
-
-    When I send PUT to 'http://localhost:7001/mirage/defaults'
-    When I send GET to 'http://localhost:7001/mirage/responses/greeting'
-    Then 'hello' should be returned
-    When I send GET to 'http://localhost:7001/mirage/responses/a_new_response'
-    Then a 404 should be returned
-
-  @command_line
-  Scenario: Mirage is started with a bad file
-    Given the file 'responses/default_greetings.rb' contains:
-    """
-    A file with a mistake in it
-    """
-    When I run 'mirage start'
-    Then I should see 'WARN: Unable to load default responses from: responses/default_greetings.rb' on the command line
-
-
-  Scenario: Mirage is primed with a bad file after it has been started
-    Given I run 'mirage start'
-    When the file 'responses/default_greetings.rb' contains:
-    """
-    A file with a mistake in it
-    """
-    And I send PUT to 'http://localhost:7001/mirage/defaults'
-    Then a 500 should be returned

data/features/server/requests/delete.feature

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

data/features/server/requests/get.feature

@@ -1,13 +1,23 @@
-Feature: After a response has been served from Mirage, the content of the request that triggered it can be retrieved. This is useful
-  for testing that the correct information was sent to the endpoint.
+Feature: 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.
 
-  On putting a respons template on to Mirage, a unique id is returned which can be used to look up the last request made to get that response.
+  Use a template's ID to retrieve the last request that was last received.
 
-  If the request body contains content this is stored. Otherwise it is the query string that is stored.
 
   Background: A template has already be put on Mirage
-    Given I send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'Hello' and headers:
-      | X-mirage-method | POST |
+    Given the following template template:
+    """
+      {
+         "request" : {
+            "http_method" : "post"
+         },
+         "response":{
+            "body":"Hello"
+         }
+      }
+    """
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to 'http://localhost:7001/mirage/templates/greeting'
 
 
   Scenario: Getting request data when the data was in the body.
@@ -15,18 +25,11 @@ Feature: After a response has been served from Mirage, the content of the reques
     """
     Hello Mirage
     """
-    When I send GET to 'http://localhost:7001/mirage/requests/1'
-    Then 'Hello Mirage' should be returned
-
+    When GET is sent to 'http://localhost:7001/mirage/requests/1'
+    Then request data should have been retrieved
 
-  Scenario: Getting request data when the data was in the query string.
-    Given I send POST to 'http://localhost:7001/mirage/responses/greeting' with parameters:
-      | surname   | Davis |
-      | firstname | Leon  |
-    When I send GET to 'http://localhost:7001/mirage/requests/1'
-    Then 'surname=Davis&firstname=Leon' should be returned
 
+  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'
+    Then a 404 should be returned
 
-  Scenario: Getting request data for a template that has not been served yet.
-    Given I send GET to 'http://localhost:7001/mirage/requests/1'
-    Then a 404 should be returned

data/features/server/save_and_revert.feature

@@ -1,22 +1,35 @@
 Feature: Having set up the Mirage with a number of defaults, your tests may continue to change its state.
   Clearing and resetting all of your responses, potentially hundreds of times, can be time expensive.
 
-  Mirage provides the ability to save of its current state and to revert it back to that state.
+  Mirage provides the ability to save its current state and to revert back to that state.
 
   Background: The MockServer has been setup with some default responses
-    Given I send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'The default greeting'
+    Given the following template template:
+    """
+      {
+         "response":{
+            "body":"The default greeting"
+         }
+      }
+    """
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to 'http://localhost:7001/mirage/templates/greeting'
 
     
   Scenario: Saving Mirage and reverting it
-    And I send PUT to 'http://localhost:7001/mirage/backup'
+    Given PUT is sent to 'http://localhost:7001/mirage/backup'
+    And the following template template:
+    """
+      {
+         "response":{
+            "body":"Changed"
+         }
+      }
+    """
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to 'http://localhost:7001/mirage/templates/greeting'
     
-    Given I send PUT to 'http://localhost:7001/mirage/templates/leaving' with body 'Goodbye'
-    And I send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'Changed'
-    
-    And I send PUT to 'http://localhost:7001/mirage'
-
-    When I send GET to 'http://localhost:7001/mirage/responses/leaving'
-    Then a 404 should be returned
+    When PUT is sent to 'http://localhost:7001/mirage'
+    And GET is sent to 'http://localhost:7001/mirage/responses/greeting'
 
-    When I send GET to 'http://localhost:7001/mirage/responses/greeting'
     Then 'The default greeting' should be returned

data/features/server/templates/delete.feature

@@ -1,47 +1,44 @@
-Feature: Templates can be deleted, doing so means that the coresponding response is no longer hosted and it 
-  also deletes any associated request data.
-
+Feature: When a template is deleted, any tracked request data is also removed.
 
   Background: The MockServer has already got a response for greeting and leaving on it.
-    Given I send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'Hello'
-    And I send GET to 'http://localhost:7001/mirage/responses/greeting'
-
-    And I send PUT to 'http://localhost:7001/mirage/templates/leaving' with body 'Goodbye'
-    And I send GET to 'http://localhost:7001/mirage/responses/leaving'
+    Given the following template template:
+    """
+      {
+         "response":{
+            "body":"Hello"
+         }
+      }
+    """
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to 'http://localhost:7001/mirage/templates/greeting'
+
+    Given the following template template:
+    """
+      {
+         "response":{
+            "body":"Goodbye"
+         }
+      }
+    """
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to 'http://localhost:7001/mirage/templates/leaving'
 
 
   Scenario: Deleting all templates
-    Given I send DELETE to 'http://localhost:7001/mirage/templates'
-
-    When I send GET to 'http://localhost:7001/mirage/requests/1'
-    Then a 404 should be returned
-    When I send GET to 'http://localhost:7001/mirage/responses/greeting'
+    Given DELETE is sent to 'http://localhost:7001/mirage/templates'
+    When GET is sent to 'http://localhost:7001/mirage/responses/greeting'
     Then a 404 should be returned
-    When I send GET to 'http://localhost:7001/mirage/templates/1'
-    Then a 404 should be returned
-
-    When I send GET to 'http://localhost:7001/mirage/requests/2'
-    Then a 404 should be returned
-    When I send GET to 'http://localhost:7001/mirage/responses/leaving'
-    Then a 404 should be returned
-    When I send GET to 'http://localhost:7001/mirage/templates/2'
+    When GET is sent to 'http://localhost:7001/mirage/responses/leaving'
     Then a 404 should be returned
 
 
   Scenario: Deleting a particular template
-    Given I send DELETE to 'http://localhost:7001/mirage/templates/1'
+    Given DELETE is sent to 'http://localhost:7001/mirage/templates/1'
 
-    When I send GET to 'http://localhost:7001/mirage/templates/1'
-    Then a 404 should be returned
-    When I send GET to 'http://localhost:7001/mirage/responses/greeting'
-    Then a 404 should be returned
-    When I send GET to 'http://localhost:7001/mirage/requests/1'
+    When GET is sent to 'http://localhost:7001/mirage/responses/greeting'
     Then a 404 should be returned
 
-    When I send GET to 'http://localhost:7001/mirage/requests/2'
-    Then a 200 should be returned
-    When I send GET to 'http://localhost:7001/mirage/responses/leaving'
-    Then a 200 should be returned
-    When I send GET to 'http://localhost:7001/mirage/templates/2'
+    When GET is sent to 'http://localhost:7001/mirage/responses/leaving'
     Then a 200 should be returned
+
     

data/features/server/templates/get.feature

@@ -1,31 +1,50 @@
-Feature: If you want to see the content of a particular response without triggering then it can be peeked instead.
-  To do this, the responses unique id is required to identify it
-    
+Feature: Templates can be retrieved by using the ID that was returned when they were created
 
-  #TODO should return headers as well
-  Scenario: Peeking a text based response
-    Given I send PUT to 'http://localhost:7001/mirage/templates/xml' with body '<xml></xml>' and headers:
-      | content-type | text/xml |
 
-    When I send GET to 'http://localhost:7001/mirage/templates/1'
-    Then '<xml></xml>' should be returned
-    And the response 'content-type' should be 'text/xml'
-
-
-  Scenario: Peeking a file based response
-    Given the file 'test_file.txt' contains:
+  Scenario: Retrieving a template
+    Given the following template template:
     """
-    test content
+      {
+         "response":{
+            "default":false,
+            "body":"Hello",
+            "delay":0,
+            "content_type":"text/plain",
+            "status":200
+         },
+         "request":{
+            "parameters":{
+
+            },
+            "body_content":[
+
+            ],
+            "http_method":"get"
+         }
+      }
+    """
+    And the template is sent using PUT to 'http://localhost:7001/mirage/templates/greeting'
+    When GET is sent to 'http://localhost:7001/mirage/templates/1'
+    Then the following should be returned:
+    """
+      {
+         "response":{
+            "default":false,
+            "body":"Hello",
+            "delay":0,
+            "content_type":"text/plain",
+            "status":200
+         },
+         "request":{
+            "parameters":{
+
+            },
+            "body_content":[
+
+            ],
+            "http_method":"get"
+         }
+      }
     """
-    And I send PUT to 'http://localhost:7001/mirage/templates/some/location/download' with file: test_file.txt and headers:
-      | X-mirage-file | true |
-
-    When I send GET to 'http://localhost:7001/mirage/templates/1'
-    Then the response should be the same as the content of 'test_file.txt'
-
-
-  Scenario: Peeking a response that does not exist
-    When I send GET to 'http://localhost:7001/mirage/templates/1'
-    Then a 404 should be returned