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

data/features/support/command_line.rb

@@ -14,7 +14,7 @@ module CommandLine
   end
 
   def normalise text
-    text.gsub(/[\n]/, ' ').gsub(/\s+/, ' ')
+    text.gsub(/[\n]/, ' ').gsub(/\s+/, ' ').strip
   end
 end
 

data/features/templates/delete.feature

@@ -0,0 +1,45 @@
+Feature: Deleting
+  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 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'
+
+
+  Scenario: Deleting all templates
+    Given DELETE is sent to '/templates'
+    When GET is sent to '/responses/greeting'
+    Then a 404 should be returned
+    When GET is sent to '/responses/leaving'
+    Then a 404 should be returned
+
+
+  Scenario: Deleting a particular template
+    Given DELETE is sent to '/templates/1'
+
+    When GET is sent to '/responses/greeting'
+    Then a 404 should be returned
+
+    When GET is sent to '/responses/leaving'
+    Then a 200 should be returned
+
+    

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

@@ -1,4 +1,5 @@
-Feature: Templates can be retrieved by using the ID that was returned when they were created
+Feature: Retrieving
+  Templates can be retrieved by using the ID that was returned when they were created
 
 
   Scenario: Retrieving a template
@@ -23,11 +24,14 @@ Feature: Templates can be retrieved by using the ID that was returned when they
          }
       }
     """
-    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:
+    And the template is sent using PUT to '/templates/greeting'
+    When GET is sent to '/templates/1'
+    Then the following json should be returned:
     """
       {
+         "id": 1,
+         "endpoint": "greeting",
+         "requests_url": "http://localhost:7001/requests/1",
          "response":{
             "default":false,
             "body":"Hello",
@@ -39,8 +43,8 @@ Feature: Templates can be retrieved by using the ID that was returned when they
             "parameters":{
 
             },
+            "headers":{},
             "body_content":[
-
             ],
             "http_method":"get"
          }

data/features/templates/put.feature

@@ -0,0 +1,77 @@
+Feature: Creating a Template
+  Mirage can be configured with Templates. Templates describe the characteristics of responses that should be returned to a client. In addition to this a templates also describe the conditions under which a template may be used to generate a response.
+
+  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.
+
+  More than one Template can be placed at the same resource address as long as they have different request contraints. In this case they are given different IDs. For example if two templates are configured to respond to request using different HTTP methods then they will not overwrite each other but both be stored.
+
+  Requirements can be specified as required when configuring a Template:
+  * request parameters
+  * body content
+  * HTTP Headers
+  * HTTP Method
+
+  The following attributes of a response can be configured
+  * HTTP status code
+  * 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 and floats are accepted
+  * Content-Type
+
+  Things to note:
+  ---------------
+  The body attribute of the response should be Base64 encoded. This is so that you may specify binary data if that is what you would like to send back to clients.
+
+
+  Scenario: Setting a Template on Mirage
+    Given the following Template JSON:
+    """
+      {
+         "request":{
+            "parameters":{},
+            "http_method":"get",
+            "headers": {},
+            "body_content":[]
+         },
+         "response":{
+            "default":false,
+            "body":"SGVsbG8=",
+            "delay":0,
+            "content_type":"text/plain",
+            "status":200
+         }
+      }
+    """
+    When the template is sent using PUT to '/templates/greeting'
+    Then '{"id":1}' should be returned
+
+    When GET is sent to '/responses/greeting'
+    Then 'Hello' should be returned
+    And a 200 should be returned
+
+
+  Scenario: Template defaults
+    Given the following Template JSON:
+    """
+    {}
+    """
+    When the template is sent using PUT to '/templates/greeting'
+    Then the template request specification should have the following set:
+      | Setting      | Default |
+      | parameters   | none    |
+      | body content | none    |
+      | headers      | none    |
+      | HTTP method  | GET     |
+    And the template response specification should have the following set:
+      | Setting      | Default    |
+      | default      | false      |
+      | body         | none       |
+      | content_type | text/plain |
+      | delay        | 0          |
+      | status       | 200        |
+
+  Scenario: Making a request that is unmatched
+    When GET is sent to '/responses/unmatched'
+    Then a 404 should be returned
+

data/features/{server/templates/put → templates}/put_with_substitutions.feature

@@ -1,4 +1,5 @@
-Feature: Parts of a response can be substitued for values found in the request body or query string.
+Feature: Substituting values from requests in to a template
+  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, matchers must be put in the the response value.
@@ -15,7 +16,7 @@ Feature: Parts of a response can be substitued for values found in the request b
       }
     """
     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:
+    And the template is sent using PUT to '/templates/greeting'
+    When I send GET to '/responses/greeting' with parameters:
       |name|Joe  |
     Then 'Hello Joe' should be returned

data/features/templates/readme.md

@@ -0,0 +1,7 @@
+Templates are the descriptors pushed to Mirage to tell it what to return to a client.
+
+They can be configured to place restrictions on the requests that should be met before they are allowed to be used to generate a response.
+
+title
+-----
+

data/features/{server/templates/put → templates}/required_content.feature

@@ -1,4 +1,5 @@
-Feature: Templates set requirements on the following in order for them to be used to generate responses:
+Feature: Placing requirements on requests
+  If you want Mirage to be choosy when using a Template to generate a response the following can have requirements placed on them when looking for a suitable to Template to generate responses:
 
   * request parameters
   * body content
@@ -27,29 +28,28 @@ Feature: Templates set requirements on the following in order for them to be use
       }
     """
     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'
 
-  #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 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 '/templates/greeting'
 
 
   Scenario: Configuring a template with requirements on request parameters
@@ -74,9 +74,9 @@ Feature: Templates set requirements on the following in order for them to be use
       }
     """
     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 I send GET to 'http://localhost:7001/mirage/responses/greeting' with parameters:
+    When I send GET to '/responses/greeting' with parameters:
     |firstname|Joe  |
     |surname  |Blogs|
     Then 'Hello Joe' should be returned
@@ -100,17 +100,9 @@ Feature: Templates set requirements on the following in order for them to be use
       }
     """
     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 I send POST to 'http://localhost:7001/mirage/responses/greeting' with body:
-      """
-        {
-          "credentials" : {
-            "username" : "Joe",
-            "password" : "Blogs"
-          }
-        }
-      """
+    When I send POST to '/responses/greeting' with body '{"username":"Joe Blogs"}'
     Then 'Hello Joe' should be returned
 
 

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

@@ -1,4 +1,5 @@
-Feature: Mirage's home page allows you to see what response are currently being hosted.
+Feature: Web interface
+  Mirage's home page allows you to see what response are currently being hosted.
   From this page you can:
   - Peek at a responses content
   - Track the response to see if a request has been made to it
@@ -6,26 +7,26 @@ Feature: Mirage's home page allows you to see what response are currently being
 #TODO tests needed for displaying pattern and delay values and http method
 
   Background: There are already a couple of responses hosted on he Mirage server
-    Given I send PUT to 'http://localhost:7001/mirage/templates/greeting' with body 'hello' and headers:
+    Given I send PUT to '/templates/greeting' with body 'hello' and headers:
       | X-mirage-default | true |
       | X-mirage-method  | POST |
-    And I send PUT to 'http://localhost:7001/mirage/templates/leaving' with body 'goodbye'
+    And I send PUT to '/templates/leaving' with body 'goodbye'
 
   Scenario: Using the home page to see what response are being hosted
-    Given I goto 'http://localhost:7001/mirage'
+    Given I goto ''
     Then I should see 'greeting/*'
     Then I should see 'leaving'
 
   Scenario: Using the home page to peek at a response
-    Given I goto 'http://localhost:7001/mirage'
+    Given I goto ''
     When  I click 'peek_response_1'
     Then I should see 'hello'
 
   Scenario: Using the home page to track if a request has been made
-    Given I send POST to 'http://localhost:7001/mirage/responses/greeting' with request entity
+    Given I send POST to '/responses/greeting' with request entity
     """
     Yo!
     """
-    Given I goto 'http://localhost:7001/mirage'
+    Given I goto ''
     When  I click 'track_response_1'
     Then I should see 'Yo!'

data/lib/mirage/client/cli_bridge.rb

@@ -3,7 +3,7 @@ module CLIBridge
   def mirage_process_ids ports
     mirage_instances = {}
     ["Mirage Server", "mirage_server", "mirage server"].each do |process_name|
-      processes_with_name(process_name).lines.collect { |line| line.chomp }.each do |process_line|
+      processes_with_name(process_name).each_line.collect { |line| line.chomp }.each do |process_line|
         pid = process_line.split(' ')[1]
         port = process_line[/port (\d+)/, 1]
         mirage_instances[port] = pid

data/lib/mirage/client/client.rb

@@ -9,24 +9,33 @@ module Mirage
 
     attr_reader :url
 
-    def initialize options={:url => "http://localhost:7001/mirage"}, &block
+    def initialize options={:url => "http://localhost:7001"}, &block
       if options.is_a?(String) && options =~ URI.regexp
         warn("Client.new(url): Deprecated usage, please use :url => url | :port => port")
         @url = options
       elsif options.kind_of?(Hash) && options[:port]
-        @url = "http://localhost:#{options[:port]}/mirage"
+        @url = "http://localhost:#{options[:port]}"
       elsif options.kind_of?(Hash) && options[:url]
         @url = options[:url]
       else
         raise "specify a valid URL or port"
       end
 
+      @templates = Templates.new(@url)
+      @templates.default_config &block if block
+    end
+
+    def configure &block
       templates.default_config &block if block
     end
 
+    def reset
+      templates.default_config.reset
+    end
+
     def templates id=nil
       return Template.get("#{@url}/templates/#{id}") if id
-      Templates.new(@url)
+      @templates
     end
 
     def requests id=nil
@@ -57,5 +66,9 @@ module Mirage
     def == client
       client.instance_of?(Client) && self.url == client.url
     end
+
+    def running?
+      Mirage.running? @url
+    end
   end
 end

data/lib/mirage/client/error.rb

@@ -11,7 +11,7 @@ module Mirage
   class InternalServerException < MirageError;
   end
 
-  class ResponseNotFound < MirageError;
+  class ResponseNotFound < ::Exception
   end
 
   class ClientError < ::Exception

data/lib/mirage/client/runner.rb

@@ -42,7 +42,7 @@ module Mirage
     #   Mirage.running? :port => port -> boolean indicating whether Mirage is running on *locally* on the given port
     #   Mirage.running? url -> boolean indicating whether Mirage is running on the given URL
     def running? options_or_url = {:port => 7001}
-      url = options_or_url.kind_of?(Hash) ? "http://localhost:#{options_or_url[:port]}/mirage" : options_or_url
+      url = options_or_url.kind_of?(Hash) ? "http://localhost:#{options_or_url[:port]}" : options_or_url
       HTTParty.get(url) and return true
     rescue Errno::ECONNREFUSED
       return false

data/lib/mirage/client/template.rb

@@ -18,12 +18,14 @@ module Mirage
       alias_method :backedup_get, :get
 
       def get url
-        response_hashie = Hashie::Mash.new backedup_get(url, :format => :json)
+        response = backedup_get(url, :format => :json)
+        raise ResponseNotFound if response.code == 404
+        response_hashie = Hashie::Mash.new response
 
         response_config = response_hashie.response
         request_config = response_hashie.request
 
-        template = new(response_hashie.endpoint, response_config.body)
+        template = new(response_hashie.endpoint, Base64.decode64(response_config.body))
 
         template.id response_hashie.id
         template.default response_config['default']

data/lib/mirage/client/template/configuration.rb

@@ -29,6 +29,16 @@ module Mirage
         @caller_binding.send method, *args, &block if @caller_binding
       end
 
+      def == config
+        config.is_a?(Configuration) &&
+            http_method == config.http_method &&
+            status == config.status &&
+            delay == config.delay &&
+            content_type == config.content_type &&
+            default == config.default
+
+      end
+
     end
   end
 end

data/lib/mirage/client/template/model/instance_methods.rb

@@ -49,16 +49,15 @@ module Mirage
                   :status => status,
                   :default => default,
                   :content_type => content_type,
-                  :headers => headers
-
+                  :headers => headers,
+                  :delay => delay
               },
               :request => {
                   :parameters => encode_regexs(required_parameters),
                   :headers => encode_regexs(required_headers),
                   :body_content => encode_regexs(required_body_content),
                   :http_method => http_method,
-              },
-              :delay => delay
+              }
           }.to_json
         end