mirage 0.1.2

data/features/client/getting_responses.feature

@@ -0,0 +1,30 @@
+Feature: the Mirage client provides a method for getting responses
+  There is no need to escape any parameters before using the client api as this is done for you.
+
+  Background:
+    Given the following gems are required to run the Mirage client test code:
+    """
+    require 'rubygems'
+    require 'rspec'
+    require 'mirage'
+    """
+    And I post to 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | hello |
+
+  Scenario: getting a response
+    Given I run
+    """
+    Mirage::Client.new.get('greeting').should == 'hello'
+    """
+
+  Scenario: getting a response that does not exist
+    Given I run
+    """
+    begin
+      Mirage::Client.new.get('response_that_does_not_exits').should == 'hello'
+      fail("Error should have been thrown")
+    rescue Exception => e
+      e.is_a?(Mirage::ResponseNotFound).should == true
+    end
+    """
+

data/features/client/mirage_client.feature

@@ -0,0 +1,36 @@
+@command_line
+Feature: Interacting with Mirage is done via HTTP using  REST style URLs and therefore you can interact with it in any language.
+  If however you are using Ruby, and you want to, you can use the Mirage Client that comes in the Mirage distribution.
+
+  By default the client is configured to connect to an instance of the Mirage server on localhost:7001 which is where
+  the Mirage server starts on by default.
+
+  Background:
+    Given the following gems are required to run the Mirage client test code:
+    """
+    require 'rubygems'
+    require 'rspec'
+    require 'mirage'
+    """
+
+
+  Scenario: checking if mirage is running
+    Then I run
+    """
+      Mirage::Client.new.running?.should == false
+    """
+    Given Mirage is running
+    Then I run
+    """
+      Mirage::Client.new.running?.should == true
+    """
+
+
+  Scenario: connecting to mirage running on a different url
+    Given I run 'mirage start -p 9001'
+    Then I run
+    """
+      Mirage::Client.new("http://localhost:9001/mirage").running?.should == true
+    """
+
+

data/features/client/peeking.feature

@@ -0,0 +1,32 @@
+Feature: the client can be used for peeking at responses hosted on Mirage.
+
+  Background:
+    Given the following gems are required to run the Mirage client test code:
+    """
+    require 'rubygems'
+    require 'rspec'
+    require 'mirage'
+    """
+
+  Scenario: peeking a response
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello |
+
+    When I run
+    """
+      Mirage::Client.new.peek(1).should == 'Hello'
+    """
+
+    When I hit 'http://localhost:7001/mirage/check/1'
+    Then a 404 should be returned
+
+  Scenario: getting a response that does not exist
+    Given I run
+    """
+    begin
+      Mirage::Client.new.peek(2).should == 'this should not have happened'
+      fail("Error should have been thrown")
+    rescue Exception => e
+      e.is_a?(Mirage::ResponseNotFound).should == true
+    end
+    """

data/features/client/setting_responses.feature

@@ -0,0 +1,91 @@
+Feature: the Mirage client provides methods for setting responses and loading default responses.
+  There is no need to escape any parameters before using the client api as this is done for you.
+
+  Background:
+    Given the following gems are required to run the Mirage client test code:
+    """
+    require 'rubygems'
+    require 'rspec'
+    require 'mirage'
+    """
+
+  Scenario: Setting a basic response
+    Given I run
+    """
+    Mirage::Client.new.set('greeting',:response => 'hello')
+    """
+    When I hit 'http://localhost:7001/mirage/get/greeting'
+    Then 'hello' should be returned
+
+  Scenario: Setting a response with a pattern
+    Given I run
+    """
+    Mirage::Client.new.set('greeting', :response => 'Hello Leon', :pattern => '.*?>leon</name>')
+    """
+    When I hit 'http://localhost:7001/mirage/get/greeting'
+    Then a 404 should be returned
+    When I hit 'http://localhost:7001/mirage/get/greeting' with request body:
+    """
+     <greetingRequest>
+      <name>leon</name>
+     </greetingRequest>
+    """
+    Then 'Hello Leon' should be returned
+
+  Scenario: Loading default responses
+    Given Mirage is not running
+    And I run 'mirage start'
+
+    When the file 'defaults/default_greetings.rb' contains:
+    """
+    Mirage.default do |mirage|
+      mirage.set('greeting', :response => 'hello')
+      mirage.set('leaving', :response => 'goodbye')
+    end
+    """
+    And I run
+    """
+    Mirage::Client.new.load_defaults
+    """
+    And I hit 'http://localhost:7001/mirage/get/greeting'
+    Then 'hello' should be returned
+
+    When I hit 'http://localhost:7001/mirage/get/leaving'
+    Then 'goodbye' should be returned
+
+
+  Scenario: Setting defaults and one of the files has something bad in it
+    Given the file 'defaults/default_greetings.rb' contains:
+    """
+    Something bad...
+    """
+    When I run
+    """
+    begin
+      Mirage::Client.new.load_defaults
+      fail("Error should have been thrown")
+    rescue Exception => e
+      e.is_a?(Mirage::InternalServerException).should == true
+    end
+    """
+
+
+  Scenario: Setting a file as a response
+    Given I run
+    """
+    Mirage::Client.new.set('download', :file => File.open('features/resources/test.zip'))
+    """
+    When I hit 'http://localhost:7001/mirage/get/download'
+    Then the response should be a file the same as 'features/resources/test.zip'
+
+
+  Scenario: A response or file is not supplied
+    Given I run
+    """
+      begin
+        Mirage::Client.new.set('download',{})
+        fail("Error should have been thrown")
+      rescue Exception => e
+        e.is_a?(Mirage::InternalServerException).should == true
+      end
+    """

data/features/client/snapshotting.feature

@@ -0,0 +1,34 @@
+Feature: The Mirage client can be used to snaphsot and rollback the Mirage server
+
+
+  Background:
+    Given the following gems are required to run the Mirage client test code:
+    """
+    require 'rubygems'
+    require 'rspec'
+    require 'mirage'
+    """
+    And I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | The default greeting |
+
+
+  Scenario: Taking a snapshot and rolling it back
+    Given I run
+    """
+    Mirage::Client.new.snapshot
+    """
+    And I hit 'http://localhost:7001/mirage/set/leaving' with parameters:
+      | response | Goodye |
+
+    And I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Changed |
+
+    When I run
+    """
+    Mirage::Client.new.rollback
+    """
+    And I hit 'http://localhost:7001/mirage/get/leaving'
+    Then a 404 should be returned
+
+    When I hit 'http://localhost:7001/mirage/get/greeting'
+    Then 'The default greeting' should be returned

data/features/command_line_iterface.feature

@@ -0,0 +1,39 @@
+@command_line
+Feature: 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:
+      | Usage: mirage start\|stop [options] |
+      | -p, --port PORT     |
+      | -d, --defaults DIR  |
+
+
+  Scenario: Starting with help option
+    Given I run 'mirage start --help'
+    Then the usage information should be displayed
+
+
+  Scenario: Starting with an invalid option
+    Given I run 'mirage start --invalid-option'
+    Then the usage information should be displayed
+
+
+  Scenario: Starting mirage
+    Given Mirage is not running
+    When I run 'mirage start'
+    Then mirage should be running on 'http://localhost:7001/mirage'
+    And 'mirage.log' should exist
+
+
+  Scenario: Stopping Mirage
+    Given I run 'mirage start'
+    When I run 'mirage stop'
+    Then Connection should be refused to 'http://localhost:7001/mirage'
+
+
+  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'

data/features/default_responses.feature

@@ -0,0 +1,91 @@
+@command_line
+Feature: Mirage can be primed with a default responses.
+  By default, Mirage loads any rb files found in ./defaults on startup. Mirage can also be made to load default responses
+  from a directory of your choosing.
+
+  Defaults can also be added/reloaded after Mirage has started
+
+
+  Scenario: Mirage is started with defaults in the standard location.
+    Given the file 'defaults/default_greetings.rb' contains:
+    """
+    Mirage.default do |mirage|
+      mirage.set('greeting', :response => 'hello')
+      mirage.set('leaving', :response => 'goodbye')
+    end
+    """
+    And I run 'mirage start'
+    When I hit 'http://localhost:7001/mirage/get/greeting'
+    Then 'hello' should be returned
+    When I hit 'http://localhost:7001/mirage/get/leaving'
+    Then 'goodbye' should be returned
+
+
+  Scenario: Mirage is started pointing with a relative path for default responses
+    Given the file './custom_default_location/default_greetings.rb' contains:
+    """
+    Mirage.default do |mirage|
+      mirage.set('greeting', :response => 'hello')
+    end
+    """
+    And I run 'mirage start -d ./custom_default_location'
+    When I hit 'http://localhost:7001/mirage/get/greeting'
+    Then 'hello' should be returned
+
+
+  Scenario: Mirage is started pointing with a full path for default responses
+    Given the file '/tmp/defaults/default_greetings.rb' contains:
+    """
+    Mirage.default do |mirage|
+      mirage.set('greeting', :response => 'hello')
+    end
+    """
+    And I run 'mirage start -d /tmp/defaults'
+    When I hit 'http://localhost:7001/mirage/load_defaults'
+    And I hit 'http://localhost:7001/mirage/get/greeting'
+    Then 'hello' should be returned
+
+
+  Scenario: Reloading default responses after mirage has been started
+    Given the file 'defaults/default_greetings.rb' contains:
+    """
+    Mirage.default do |mirage|
+      mirage.set('greeting', :response => 'hello')
+    end
+    """
+    And I run 'mirage start'
+    And I hit 'http://localhost:7001/mirage/clear'
+    And I hit 'http://localhost:7001/mirage/set/a_new_response' with parameters:
+      | response | new response |
+
+    When I hit 'http://localhost:7001/mirage/load_defaults'
+    When I hit 'http://localhost:7001/mirage/get/greeting'
+    Then 'hello' should be returned
+    When I hit 'http://localhost:7001/mirage/get/a_new_response'
+    Then a 404 should be returned
+
+
+  Scenario: Mirage is started with a bad defaults file
+    Given the file 'defaults/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: defaults/default_greetings.rb' on the command line
+
+
+  Scenario: Defaults with a mistake in them are reloaded after mirage has been started
+    Given I run 'mirage start'
+    When the file 'defaults/default_greetings.rb' contains:
+    """
+    A file with a mistake in it
+    """
+    And I hit 'http://localhost:7001/mirage/load_defaults'
+    Then a 500 should be returned
+
+
+
+
+
+
+

data/features/file_hosting.feature

@@ -0,0 +1,8 @@
+Feature: Mirage can also be used to host files.
+
+  Scenario: A file is set as a response
+    Given I hit 'http://localhost:7001/mirage/set/some/location/download' with parameters:
+      | file | features/resources/test.zip |
+
+    When I hit 'http://localhost:7001/mirage/get/some/location/download'
+    Then the response should be a file the same as 'features/resources/test.zip'

data/features/logging.feature

@@ -0,0 +1,7 @@
+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 post to 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello |
+    Then 'mirage.log' should contain '/mirage/set/greeting?response=Hello'

data/features/peeking_at_response.feature

@@ -0,0 +1,24 @@
+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
+
+
+  Scenario: Peeking a text based response
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello |
+
+    When I hit 'http://localhost:7001/mirage/peek/1'
+    Then 'Hello' should be returned
+
+
+  Scenario: Peeking a file based response
+    Given I hit 'http://localhost:7001/mirage/set/download' with parameters:
+      | file | features/resources/test.zip |
+    When I hit 'http://localhost:7001/mirage/peek/1'
+    Then the response should be a file the same as 'features/resources/test.zip'
+
+
+  Scenario: Peeking a response that does not exist
+    When I hit 'http://localhost:7001/mirage/peek/1'
+    Then a 404 should be returned
+
+

data/features/response_templates.feature

@@ -0,0 +1,45 @@
+Feature: Parts of a response can be substitued for values found in the request body or query string.
+  This allows dynamic content to be sent back to a client.
+
+  To do this, substitution patterns are put in to the response. When the response is triggered, the patterns are used to search the request body
+  and then the query string for matches. Patterns can be either the name of a parameter found in the query string, or a regular expression with a single
+  matching group which is what is put in to the response.
+
+
+  Scenario: A response template populated from match found in the request body using a regex
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello ${<name>(.*?)</name>}, how are you? |
+
+    When I hit 'http://localhost:7001/mirage/get/greeting' with request body:
+    """
+    <grettingRequest>
+      <name>Leon</name>
+    </greetingRequest>
+    """
+    Then 'Hello Leon, how are you?' should be returned
+
+
+  Scenario: A response template populated from match found in the query string using a request parameter name
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello ${name}, how are you? |
+
+    When I hit 'http://localhost:7001/mirage/get/greeting' with parameters:
+      | name | Leon |
+    Then 'Hello Leon, how are you?' should be returned
+
+  Scenario: Response template populated from match found in the query string using a regex
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello ${name=([L\|l]eon)}, how are you? |
+
+    When I hit 'http://localhost:7001/mirage/get/greeting' with parameters:
+      | parameter | value |
+      | name      | Leon  |
+    Then 'Hello Leon, how are you?' should be returned
+
+
+  Scenario: No match is found in either the request body or query string
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello ${<name>(.*?)</name>}, how are you? |
+
+    When  I hit 'http://localhost:7001/mirage/get/greeting'
+    Then 'Hello ${<name>(.*?)</name>}, how are you?' should be returned