mirage 2.4.2 → 3.0.0.alpha.1

data/features/server/templates/put/put.feature

@@ -1,85 +1,62 @@
 Feature: Mirage can be configured with templates that are returned when addressed from ${mirage_url}/responses
-  On setting a template, a unique id is retuned. This is a key that can be used to manage the template. 
-  
-  Templates can be configured to respond to either, GET, POST, PUT, or DELETE. If you put more than one template to the same address
-  but configure them to respond to different HTTP methods, then they are held as seperate resources and are assigned different ids.
-
-  Templates can have following attributes configured by setting the following HTTP headers:
-  X-mirage-pattern (optional) = criteria for when a response should be returned. see put_with_pattern.feature
-  X-mirage-delay (optional) = the amount of time in seconds that mirage should wait for before responding (defaults to 0)
-  X-mirage-method (optional) = http method that this response applies to. Can be set to GET, POST, PUT or DELETE. Templates are configured to respond to GET requests by default
-  X-mirage-default (optional) = set whether the reponse can act as a default response, see put_as_default.feature (defaults to false)
-  X-mirage-status-code (optional) = set the http status that is returned, defaults to 200
-  content-type (optional) = Set the content type to be returned
+  On setting a template, a unique id is returned. This is a key that can be used to manage the template.
 
+  Templates can be configured to respond to either, GET, POST, PUT, or DELETE. If you put more than one template to the same resource address
+  but configure them to respond to different HTTP methods, then they are held as seperate resources and are assigned different ids.
 
-  Scenario: A template without any selection criteria
-    Given I send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'Hello'
-
-    When I send GET to 'http://localhost:7001/mirage/responses/greeting'
+  The following can be configured as required in order to invoke a response:
+  * request parameters
+  * body content - defaults to text/plain
+  * HTTP Headers
+  * HTTP Method - defaults to HTTP GET
+
+  The following attributes of a response can be configured
+  * HTTP status code - defaults to 200
+  * Whether this template is to be treated as the default response if a match is not found for a sub URI
+  * A delay before the response is returned to the client. This is in seconds, floats are accepted
+  * Content-Type
+
+  Request defaults
+  |required request parameters | none |
+  |required body content       | none |
+  |require HTTP headers        | none |
+  |required HTTP method        | GET  |
+
+  Response defaults
+  | HTTP status code | 200        |
+  | treat as default | false      |
+  | delay            | 0          |
+  | Content-Type     | text/plain |
+
+
+  Scenario: Setting a template on mirage
+    Given the following template template:
+    """
+      {
+         "request":{
+            "parameters":{},
+            "http_method":"get",
+            "headers": {},
+            "body_content":[]
+         },
+         "response":{
+            "default":false,
+            "body":"Hello",
+            "delay":0,
+            "content_type":"text/plain",
+            "status":200
+         }
+      }
+    """
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to 'http://localhost:7001/mirage/templates/greeting'
+    And '{"id":1}' should be returned
+
+    When GET is sent to 'http://localhost:7001/mirage/responses/greeting'
     Then 'Hello' should be returned
     And a 200 should be returned
-    
-
-  Scenario: A template put under a deeper address
-    Given I send PUT to 'http://localhost:7001/mirage/templates/say/hello/to/me' with body 'Hello to me'
-
-    When I send GET to 'http://localhost:7001/mirage/responses/say/hello/to/me'
-    Then 'Hello to me' should be returned
-    
-
-  Scenario: Setting the content-type header
-    Given I send PUT to 'http://localhost:7001/mirage/templates/say/hello/to/me' with body '<xml></xml>' and headers:
-    |content-type|text/xml|
-
-    When I send GET to 'http://localhost:7001/mirage/responses/say/hello/to/me'
-    Then '<xml></xml>' should be returned
-    And the response 'content-type' should be 'text/xml'
 
-
-  Scenario: Putting a template to the same resource
-    Given I send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'Hello'
-    Then '1' should be returned
-
-    Given I send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'Hi'
-    Then '1' should be returned
-
-  Scenario: Setting the http status code to be returned
-    Given I send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'Hello' and headers:
-      | X-mirage-status | 202 |
-    When I send GET to 'http://localhost:7001/mirage/responses/greeting'
-    Then a 202 should be returned
-    
-    
-
-
-  Scenario Outline: Templates is configured to respond to different http methods
-    Given I send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'GET' and headers:
-      | X-mirage-method | GET |
-    And '1' should be returned
-    
-    Given I send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'POST' and headers:
-      | X-mirage-method | POST |
-    And '2' should be returned
-    
-    Given I send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'DELETE' and headers:
-      | X-mirage-method | DELETE |
-    And '3' should be returned
-    
-    Given I send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'PUT' and headers:
-      | X-mirage-method | PUT |
-    And '4' should be returned
-    
-    When I send <method> to 'http://localhost:7001/mirage/responses/greeting'
-    Then '<method>' should be returned
-  Examples:
-    | method |
-    | GET    |
-    | POST   |
-    | PUT    |
-    | DELETE |
-
-
-  Scenario: Getting a response for a template resources that does not exist
-    When I send GET to 'http://localhost:7001/mirage/responses/response_that_does_not_exist'
+  Scenario: Making a request that is unmatched
+    When GET is sent to 'http://localhost:7001/mirage/responses/unmatched'
     Then a 404 should be returned
+

data/features/server/templates/put/put_with_substitutions.feature

@@ -1,41 +1,21 @@
 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.
-
+  To do this, substitution, matchers must be put in the the response value.
 
+  Either a string literal or a regex can be used in between ${} to find a match
 
   Scenario: A response template populated from matches found in the request body using a regex
-    Given I send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'Hello ${<firstname>(.*?)</firstname>} ${<surname>(.*?)</surname>}, how are you?' and headers:
-      | X-mirage-method | POST |
-    When I send POST to 'http://localhost:7001/mirage/responses/greeting' with request entity
+    Given the following template template:
     """
-    <grettingRequest>
-      <firstname>Leon</firstname>
-      <surname>Davis</surname>
-    </greetingRequest>
+      {
+         "response":{
+            "body":"Hello ${name}"
+         }
+      }
     """
-    Then 'Hello Leon Davis, 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 send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'Hello ${name}, how are you?'
-    When I send GET to 'http://localhost:7001/mirage/responses/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 send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'Hello ${name=([L\|l]eon)}, how are you?'
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to 'http://localhost:7001/mirage/templates/greeting'
     When I send GET to 'http://localhost:7001/mirage/responses/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 send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'Hello ${<name>(.*?)</name>}, how are you?'
-    When  I send GET to 'http://localhost:7001/mirage/responses/greeting'
-    Then 'Hello ${<name>(.*?)</name>}, how are you?' should be returned
+      |name|Joe  |
+    Then 'Hello Joe' should be returned

data/features/server/templates/put/required_content.feature

@@ -0,0 +1,118 @@
+Feature: Templates set requirements on the following in order for them to be used to generate responses:
+
+  * request parameters
+  * body content
+  * HTTP Headers
+  * HTTP Method
+
+  When specifying requirements on Headers, request parameters or the body of a request either a litteral string
+  or a regular expression can be used for matching.
+
+  Background: There is already a default response for 'greeting'
+    Given the following template template:
+    """
+      {
+         "request":{
+            "parameters":{},
+            "http_method":"get",
+            "body_content":[]
+         },
+         "response":{
+            "default":false,
+            "body":"Hello Stranger",
+            "delay":0,
+            "content_type":"text/plain",
+            "status":200
+         }
+      }
+    """
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to 'http://localhost:7001/mirage/templates/greeting'
+
+  #TODO support http header matching
+#  Scenario: Configuring a template with requirements on HTTP headers
+#    Given the following template template:
+#    """
+#      {
+#         "request":{
+#            "parameters":{},
+#            "http_method":"get",
+#            "body_content":[]
+#         },
+#         "response":{
+#            "default":false,
+#            "body":"Hello Stranger",
+#            "delay":0,
+#            "content_type":"text/plain",
+#            "status":200
+#         }
+#      }
+#    """
+#    And 'response.body' is base64 encoded
+#    And the template is sent using PUT to 'http://localhost:7001/mirage/templates/greeting'
+
+
+  Scenario: Configuring a template with requirements on request parameters
+    Given the following template template:
+    """
+      {
+         "request":{
+            "parameters":{
+                "firstname" : "%r\{.*e}",
+                "surname"   : "Blogs"
+            },
+            "http_method":"get",
+            "body_content":[]
+         },
+         "response":{
+            "default":false,
+            "body":"Hello Joe",
+            "delay":0,
+            "content_type":"text/plain",
+            "status":200
+         }
+      }
+    """
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to 'http://localhost:7001/mirage/templates/greeting'
+
+    When I send GET to 'http://localhost:7001/mirage/responses/greeting' with parameters:
+    |firstname|Joe  |
+    |surname  |Blogs|
+    Then 'Hello Joe' should be returned
+
+  Scenario: Configuring a template with requirements on the body
+    Given the following template template:
+    """
+      {
+         "request":{
+            "parameters":{},
+            "http_method":"POST",
+            "body_content":["Joe", "%r{B..gs}"]
+         },
+         "response":{
+            "default":false,
+            "body":"Hello Joe",
+            "delay":0,
+            "content_type":"text/plain",
+            "status":200
+         }
+      }
+    """
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to 'http://localhost:7001/mirage/templates/greeting'
+
+    When I send POST to 'http://localhost:7001/mirage/responses/greeting' with body:
+      """
+        {
+          "credentials" : {
+            "username" : "Joe",
+            "password" : "Blogs"
+          }
+        }
+      """
+    Then 'Hello Joe' should be returned
+
+
+    
+      

data/features/step_definitions/my_steps.rb

@@ -1,3 +1,5 @@
+require 'base64'
+require 'hashie'
 Then /^'([^']*)' should be returned$/ do |expected_response|
   response_text = @response.body
   if response_text != expected_response
@@ -78,6 +80,10 @@ Then /^I run$/ do |text|
   end
 end
 
+Given /^the following require statements are needed:$/ do |text|
+  @code_snippet = text.gsub("\"", "\\\\\"")
+end
+
 Given /^the following gems are required to run the Mirage client test code:$/ do |text|
   @code_snippet = text.gsub("\"", "\\\\\"")
 end
@@ -94,7 +100,7 @@ When /^I send (POST|PUT) to '(http:\/\/localhost:7001\/mirage\/(.*?))' with requ
               end
 end
 
-When /^I send (GET|PUT|POST|OPTIONS|HEAD|DELETE) to '(http:\/\/localhost:\d{4}\/mirage([^']*))'$/ do |method, url, endpoint|
+When /^(GET|PUT|POST|OPTIONS|HEAD|DELETE) is sent to '(http:\/\/localhost:\d{4}\/mirage([^']*))'$/ do |method, url, endpoint|
   start_time = Time.now
   @response = case method
                 when 'GET' then
@@ -114,9 +120,15 @@ When /^I send (GET|PUT|POST|OPTIONS|HEAD|DELETE) to '(http:\/\/localhost:\d{4}\/
 end
 
 
-When /^I send PUT to '(http:\/\/localhost:7001\/mirage\/([^']*))' with body '([^']*)'$/ do |url, endpoint, body|
+When /^I send (PUT|POST) to '(http:\/\/localhost:7001\/mirage\/([^']*))' with body:$/ do |method, url, endpoint, body|
   start_time = Time.now
-  @response = http_put(url, body)
+  @response = case method
+                when 'PUT'
+                  http_put(url, body)
+                when 'POST'
+                  http_post(url, body)
+              end
+
   @response_time = Time.now - start_time
 end
 
@@ -126,7 +138,7 @@ When /^I send PUT to '(http:\/\/localhost:7001\/mirage\/([^']*))' with body '([^
     parameter, value = row[0], row[1]
     headers[parameter]=value
   end
-  @response = http_put(url, body, headers)
+  @response = http_put(url, body, :headers => headers)
 end
 
 Then /^I should see '(.*?)' on the command line$/ do |content|
@@ -172,7 +184,7 @@ When /^I send (GET|POST) to '(http:\/\/localhost:7001\/mirage\/(.*?))' with para
 end
 
 Then /^the following should be returned:$/ do |text|
-  @response.body.should == text
+  text.gsub("\n","").gsub(" ", "").should == @response.body
 end
 
 Given /^I send PUT to '(http:\/\/localhost:7001\/mirage\/(.*?))' with file: ([^']*) and headers:$/ do |url, endpoint, path, table|
@@ -183,10 +195,23 @@ Given /^I send PUT to '(http:\/\/localhost:7001\/mirage\/(.*?))' with file: ([^'
   end
 
   Dir.chdir SCRATCH do
-    http_put(url, File.new(path), headers)
+    http_put(url, File.new(path), :headers => headers)
+  end
+end
+
+Given /^I send PUT to '(http:\/\/localhost:7001\/mirage\/(.*?))' with body '([^']*)' and parameters:$/ do |url, endpoint, body, table|
+  headers = {}
+  table.raw.each do |row|
+    parameter, value = row[0], row[1]
+    headers[parameter]=value
+  end
+
+  Dir.chdir SCRATCH do
+    http_put(url, File.new("/home/team/Projects/mirage/pkg/mirage-2.1.2.gem"), :parameters => headers)
   end
 end
 
+
 When /^the response '([^']*)' should be '([^']*)'$/ do |header, value|
   @response.response[header].should include(value)
 end
@@ -195,4 +220,24 @@ Then /^the response should be the same as the content of '([^']*)'$/ do |path|
   Dir.chdir SCRATCH do
     @response.body.should == File.read(path)
   end
+end
+Given /^the following template template:$/ do |text|
+  @response_template = Hashie::Mash.new(JSON.parse(text))
+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"})
+end
+Given /^a template for '(.*)' has been set with a value of '(.*)'$/ do |endpoint, value|
+  $mirage.templates.put(endpoint, value)
+end
+Then /^request data should have been retrieved$/ do
+  puts @response.body
+  request_data = JSON.parse(@response.body)
+  request_data.include?('parameters').should == true
+  request_data.include?('headers').should == true
+  request_data.include?('body').should == true
+  request_data.include?('request_url').should == true
 end

data/features/support/env.rb

@@ -22,5 +22,5 @@ else
   MIRAGE_CMD = "#{RUBY_CMD} ../bin/mirage"
 end
 
-World(Mirage::Web)
+
 

data/features/support/hooks.rb

@@ -1,11 +1,8 @@
 Before do
   FileUtils.mkdir_p(SCRATCH)
 
-  if Mirage.running?
-    $mirage.clear
-  else
-    $mirage = start_mirage_in_scratch_dir
-  end
+  $mirage = start_mirage_in_scratch_dir
+  $mirage.templates.delete_all
 
   Dir["#{SCRATCH}/*"].each do |file|
     FileUtils.rm_rf(file) unless file == "#{SCRATCH}/mirage.log"

data/{lib/mirage/client → features/support}/web.rb

@@ -13,7 +13,10 @@ module Mirage
       end
     end
 
-    def http_put url, entity, headers={}
+    def http_put url, entity, options={}
+      if options[:parameters]
+        url << "?#{options[:parameters].to_a.collect{|pair|pair.join("=")}.join("&")}"
+      end
       uri = URI.parse(url)
       request = Net::HTTP::Put.new(uri.request_uri)
 
@@ -23,8 +26,15 @@ module Mirage
       else
         request.body=entity
       end
-      headers.each { |field, value| request.add_field(field, value) }
-      
+
+      if options[:headers]
+        options[:headers].each { |field, value| request.add_field(field, value) }
+      end
+
+      #if options[:parameters]
+      #  request.set_form_data options[:parameters]
+      #end
+
       Net::HTTP.new(uri.host, uri.port).request(request)
     end
 
@@ -56,3 +66,4 @@ module Mirage
 
   end
 end
+World(Mirage::Web)