mirage 1.3.6 → 2.0.0.alpha1

data/features/server/web_user_interface.feature

@@ -2,15 +2,14 @@ Feature: Mirage's home page allows you to see what response are currently being
   From this page you can:
   - Peek at a responses content
   - Track the response to see if a request has been made to it
-  
-  #TODO tests needed for displaying pattern and delay values
+
+#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 hit 'http://localhost:7001/mirage/set/greeting' with parameters:
-      | response      | hello |
-      | default | true  |
-    And I hit 'http://localhost:7001/mirage/set/leaving' with parameters:
-      | response | goodbye |
+    Given I send PUT to 'http://localhost:7001/mirage/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'
 
   Scenario: Using the home page to see what response are being hosted
     Given I goto 'http://localhost:7001/mirage'
@@ -23,7 +22,7 @@ Feature: Mirage's home page allows you to see what response are currently being
     Then I should see 'hello'
 
   Scenario: Using the home page to track if a request has been made
-    Given I hit 'http://localhost:7001/mirage/get/greeting' with request body:
+    Given I send POST to 'http://localhost:7001/mirage/responses/greeting' with request entity
     """
     Yo!
     """

data/features/step_definitions/my_steps.rb

@@ -6,18 +6,16 @@ After('@command_line') do
   stop_mirage
 end
 
-Then /^'(.*?)' should be returned$/ do |expected_response|
+Then /^'([^']*)' should be returned$/ do |expected_response|
   response_text = @response.body
-  if ["1.8.6", "1.8.7"].include?(RUBY_VERSION) && response_text != expected_response
-    expected_response.length.should == response_text.length
+  if response_text != expected_response
     expected_response.split('&').each { |param_value_pair| response_text.should =~ /#{param_value_pair}/ }
-  else
-    response_text.should == expected_response
+    expected_response.length.should == response_text.length
   end
 end
 
-Then /^a (404|500) should be returned$/ do |error_code|
-  @response.code.should == error_code.to_i
+Then /^a (200|404|500) should be returned$/ do |error_code|
+  @response.code.to_i.should == error_code.to_i
 end
 
 Then /^it should take at least '(.*)' seconds$/ do |time|
@@ -25,12 +23,6 @@ Then /^it should take at least '(.*)' seconds$/ do |time|
 end
 
 
-Then /^the response should be a file the same as '([^']*)'$/ do |file_path|
-  download_path = "#{SCRATCH}/temp.download"
-  @response.save_as(download_path)
-  FileUtils.cmp(download_path, file_path).should == true
-end
-
 Then /^mirage should be running on '(.*)'$/ do |url|
   get(url).code.to_i.should == 200
 end
@@ -49,13 +41,11 @@ Given /^Mirage (is|is not) running$/ do |running|
 end
 
 Then /^Connection should be refused to '(.*)'$/ do |url|
-
   begin
     get(url)
     fail "Mirage is still running"
   rescue Errno::ECONNREFUSED
   end
-
 end
 
 Given /^the file '(.*)' contains:$/ do |file_path, content|
@@ -74,7 +64,7 @@ Then /^the usage information should be displayed$/ do
 end
 Given /^usage information:$/ do |table|
   @usage = table.raw.flatten.collect { |line| normalise(line) }
-end
+end                                                                                                                                                                         
 
 Then /^I run$/ do |text|
   text.gsub!("\"", "\\\\\"")
@@ -85,24 +75,51 @@ Given /^the following gems are required to run the Mirage client test code:$/ do
   @code_snippet = text.gsub("\"", "\\\\\"")
 end
 
-When /^I hit '(http:\/\/localhost:7001\/mirage\/(.*?))'$/ do |url, response_id|
-  @response = hit_mirage(url)
+When /^I send (POST|PUT) to '(http:\/\/localhost:7001\/mirage\/(.*?))' with request entity$/ do |method, url, endpoint, entity|
+
+  @response = case method
+                when 'POST'
+                then
+                  post(url, entity)
+                when 'PUT'
+                then
+                  put(url, entity)
+              end
 end
 
-When /^I (hit|get|post to) '(http:\/\/localhost:7001\/mirage\/(.*?))' with parameters:$/ do |http_method, url, endpoint, table|
+When /^I send (GET|PUT|POST|OPTIONS|HEAD|DELETE) to '(http:\/\/localhost:7001\/mirage([^']*))'$/ do |method, url, endpoint|
+  start_time = Time.now
+  @response = case method
+                when 'GET' then
+                  get(url)
+                when 'PUT' then
+                  put(url, '')
+                when 'POST' then
+                  post(url, '')
+                when 'HEAD' then
+                  head(url)
+                when 'OPTIONS' then
+                  options(url)
+                when 'DELETE' then
+                  delete(url)
+              end
+  @response_time = Time.now - start_time
+end
 
-  parameters = {}
-  table.raw.each do |row|
-    parameter, value = row[0].to_sym, row[1]
-    value = File.exists?(value) ? File.open(value, 'rb') : value
-    parameters[parameter]=value
-  end
 
-  @response = hit_mirage(url, parameters)
+When /^I send PUT to '(http:\/\/localhost:7001\/mirage\/([^']*))' with body '([^']*)'$/ do |url, endpoint, body|
+  start_time = Time.now
+  @response = put(url, body)
+  @response_time = Time.now - start_time
 end
 
-When /^I hit '(http:\/\/localhost:7001\/mirage\/(.*?))' with request body:$/ do |url, endpoint, request_body|
-  @response = hit_mirage(url, {:body => request_body})
+When /^I send PUT to '(http:\/\/localhost:7001\/mirage\/([^']*))' with body '([^']*)' and headers:$/ do |url, endpoint, body, table|
+  headers = {}
+  table.raw.each do |row|
+    parameter, value = row[0], row[1]
+    headers[parameter]=value
+  end
+  @response = put(url, body, headers)
 end
 
 Then /^I should see '(.*?)' on the command line$/ do |content|
@@ -128,4 +145,42 @@ end
 
 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|
+
+  parameters = {}
+  table.raw.each do |row|
+    parameter, value = row[0].to_sym, row[1]
+    value = File.exists?(value) ? File.open(value, 'rb') : value
+    parameters[parameter]=value
+  end
+
+  @response = case http_method
+                when 'POST' then
+                  post(url, parameters)
+                when 'GET' then
+                  get(url, parameters)
+              end
+end
+
+Then /^the following should be returned:$/ do |text|
+  @response.body.should == text
+end
+
+Given /^I send PUT to '(http:\/\/localhost:7001\/mirage\/(.*?))' with file: ([^']*) and headers:$/ do |url, endpoint, path, table|
+  headers = {}
+  table.raw.each do |row|
+    parameter, value = row[0], row[1]
+    headers[parameter]=value
+  end
+  put(url, File.new(path), headers)
+end
+
+When /^the response '([^']*)' should be '([^']*)'$/ do |header, value|
+  @response.response[header].should include(value)
+end
+
+Then /^the response should be the same as the content of '([^']*)'$/ do |path|
+  @response.body.should == File.read(path)
 end

data/features/support/env.rb

@@ -48,20 +48,6 @@ end
 module Web
   include Mirage::Web
 
-  def get(url)
-    browser = Mechanize.new
-    browser.keep_alive= false
-    browser.get(url)
-  end
-
-  def hit_mirage(url, parameters={})
-    start_time = Time.now
-    file = parameters.values.find { |value| value.is_a?(File) }
-    response = (file ? http_post(url, parameters) : http_get(url, parameters))
-    @response_time = Time.now - start_time
-    response
-  end
-
   def normalise text
     text.gsub(/[\n]/, ' ').gsub(/\s+/, ' ')
   end

data/lib/mirage.rb

@@ -1,5 +1,8 @@
+require 'mirage/object'
 require 'mirage/web'
 require 'mirage/util'
+require 'mirage/mock_response'
+require 'mirage/mock_responses_collection'
 require 'mirage/core'
 require 'mirage/client'
 

data/lib/mirage/client.rb

@@ -1,5 +1,4 @@
 require 'uri'
-require 'mechanize'
 require 'open-uri'
 require 'mirage/web'
 
@@ -13,6 +12,12 @@ module Mirage
       @code = message, code
     end
   end
+  
+  class Response
+    
+    attr_accessor :method, :pattern, :content_type
+    
+  end
 
   class InternalServerException < MirageError;
   end
@@ -32,24 +37,6 @@ module Mirage
       @url = url
     end
 
-    # Get a response at the given endpoint
-    # Mirage::Client.get(endpoint) => response as a string
-    # If a response is not found a ResponseNotFound exception is thrown
-    #
-    #   Examples:
-    #   Getting a response without any parameters or body content
-    #   Mirage::Client.get(endpoint)
-    #
-    #   Getting a response, passing request parameters
-    #   Mirage::Client.new.get('greeting', :param1 => 'value1', param2=>'value2')
-    #
-    #   Getting a response, passing a content in the body of the request
-    #   Mirage::Client.new.get('greeting',  'content')
-
-    def get endpoint, body_or_params={}
-      body_or_params = {:body => body_or_params} if body_or_params.is_a?(String)
-      response(http_get("#{@url}/get/#{endpoint}", body_or_params))
-    end
 
     # Set a text or file based response, to be hosted at a given end point optionally with a given pattern and delay
     # Client.set(endpoint, response, params) => unique id that can be used to call back to the server
@@ -59,16 +46,31 @@ module Mirage
     #  Client.set('greeting', 'hello', :pattern => /regexp/)
     #  Client.set('greeting', 'hello', :pattern => 'text')
     #  Client.set('greeting', 'hello', :delay => 5) # number of seconds
-    def set endpoint, response, params={}
-      params[:response] = response.is_a?(File) ? File.open(response.path, 'rb') : response
-      params[:pattern] = params[:pattern].source if params[:pattern].is_a?(Regexp)
-      response(http_post("#{@url}/set/#{endpoint}", params))
+    def set endpoint, response_value, params={}
+      response = Response.new
+      
+      yield response if block_given?
+      
+      headers = {}
+      headers['X-mirage-method'] = response.method.to_s if response.method
+      
+      headers['X-mirage-pattern'] = response.pattern if response.pattern
+      headers['Content-Type'] = response.content_type || 'text/plain'
+      
+      response(put("#{@url}/templates/#{endpoint}",response_value, headers))
     end
 
     # Use to look at what a response contains without actually triggering it.
     # Client.peek(response_id) => response held on the server as a String
     def peek response_id
-      response(http_get("#{@url}/peek/#{response_id}"))
+      response = response(get("#{@url}/templates/#{response_id}"))
+      case response
+        when String then
+          return response
+        when Mirage::Web::FileResponse then
+          return response.response.body
+      end
+      
     end
 
     # Clear Content from Mirage
@@ -81,19 +83,19 @@ module Mirage
     #   Client.new.clear(:requests) # Clear all tracked request information
     #   Client.new.clear(:request => response_id) # Clear the tracked request for a given response id
     def clear thing=nil
+      
       case thing
-        when NilClass then
-          http_get("#{@url}/clear")
-        when Fixnum then
-          http_get("#{@url}/clear/#{thing}")
-        when :requests then
-          http_get("#{@url}/clear/requests")
+        when :requests
+          delete("#{@url}/requests")
+        when Numeric then
+          delete("#{@url}/templates/#{thing}")
         when Hash then
-          case thing.keys.first
-            when :request then
-              http_get("#{@url}/clear/request/#{thing.values.first}")
-          end
+          puts "deleteing request #{thing[:request]}"
+          delete("#{@url}/requests/#{thing[:request]}") if thing[:request]
+        else NilClass
+          delete("#{@url}/templates")
       end
+      
     end
 
 
@@ -103,40 +105,43 @@ module Mirage
     #   Example:
     #   Client.new.track(response_id) => Tracked request as a String
     def track response_id
-      response(http_get("#{@url}/track/#{response_id}"))
+      response(get("#{@url}/requests/#{response_id}"))
     end
 
     # Save the state of the Mirage server so that it can be reverted back to that exact state at a later time.
     def save
-      http_post("#{@url}/save").code == 200
+      put("#{@url}/backup",'').code == 200
     end
 
 
     # Revert the state of Mirage back to the state that was last saved
     # If there is no snapshot to rollback to, nothing happens
     def revert
-      http_post("#{@url}/revert").code == 200
+      put("#{@url}",'').code == 200
     end
 
 
     # Check to see if Mirage is up and running
     def running?
-      !http_get(@url).is_a?(Errno::ECONNREFUSED)
+      begin
+        get(@url) and return true
+      rescue Errno::ECONNREFUSED
+        return false
+      end
     end
 
     # Clear down the Mirage Server and load any defaults that are in Mirages default responses directory.
     def prime
-      response(http_post("#{@url}/prime"))
+      response(put("#{@url}/defaults",''))
     end
 
     private
     def response response
-      return Mirage::Web::FileResponse.new(response) if response.instance_of?(Mechanize::File)
-      case response.code
+      case response.code.to_i
         when 500 then
-          raise ::Mirage::InternalServerException.new(response.page.body, response.code)
+          raise ::Mirage::InternalServerException.new(response.body, response.code.to_i)
         when 404 then
-          raise ::Mirage::ResponseNotFound.new(response.page.body, response.code)
+          raise ::Mirage::ResponseNotFound.new(response.body, response.code.to_i)
         else
           response.body
       end

data/lib/mirage/core.rb

@@ -1,207 +1,120 @@
-require 'ramaze'
-require 'ramaze/helper/send_file'
+require 'sinatra/base'
+require 'sinatra/reloader'
 
-class Object
-  def deep_clone
-    Marshal.load(Marshal.dump(self))
-  end
-end
 
 module Mirage
 
-  class MockResponse
-    @@id_count = 0
-    attr_reader :response_id, :delay, :name, :pattern
-    attr_accessor :response_id
+  class MirageServer < Sinatra::Base
 
-    def initialize name, value, pattern=nil, delay=0, default=false
-      @name, @value, @pattern, @response_id, @delay, @default = name, value, pattern, @@id_count+=1, delay, default
-    end
+    REQUESTS= {}
 
-    def self.reset_count
-      @@id_count = 0
-    end
+    MOCK_RESPONSES = MockResponsesCollection.new
 
-    def default?
-      @default
-    end
+    put '/mirage/templates/*' do |name|
+      response = request.body.read
 
-    def file?
-      !@value.is_a?(String)
-    end
+      headers = request.env
+      http_method = headers['HTTP_X_MIRAGE_METHOD'] || 'GET'
 
+      pattern = headers['HTTP_X_MIRAGE_PATTERN'] ? /#{headers['HTTP_X_MIRAGE_PATTERN']}/ : :basic
 
-    def value(body='', request_parameters={}, query_string='')
-      return @value if file?
-
-      value = @value
-      value.scan(/\$\{([^\}]*)\}/).flatten.each do |pattern|
+      MOCK_RESPONSES << MockResponse.new(name, response, headers['CONTENT_TYPE'], http_method, pattern, headers['HTTP_X_MIRAGE_DELAY'].to_f, headers['HTTP_X_MIRAGE_DEFAULT'], headers['HTTP_X_MIRAGE_FILE'])
+    end
 
-        if (parameter_match = request_parameters[pattern])
-          value = value.gsub("${#{pattern}}", parameter_match)
-        end
+    ['get', 'post', 'delete', 'put'].each do |http_method|
+      send(http_method, '/mirage/responses/*') do |name|
+        body, query_string = Rack::Utils.unescape(request.body.read.to_s), request.env['QUERY_STRING']
+        record = MOCK_RESPONSES.get_response(name, http_method.upcase, body, query_string)
 
-        [body, query_string].each do |string|
-          if (string_match = find_match(string, pattern))
-            value = value.gsub("${#{pattern}}", string_match)
-          end
-        end
+        return 404 unless record
+        REQUESTS[record.response_id] = body.empty? ? query_string : body
 
+        sleep record.delay
+        send_response(record, body, request, query_string)
       end
-      value
     end
 
-    private
-    def find_match(string, regex)
-      string.scan(/#{regex}/).flatten.first
+    delete '/mirage/templates/:id' do
+      response_id = params[:id].to_i
+      MOCK_RESPONSES.delete(response_id)
+      REQUESTS.delete(response_id)
     end
-  end
-
-
-  class MirageServer < Ramaze::Controller
-    include Ramaze::Helper::SendFile
-    map '/mirage'
-    RESPONSES, REQUESTS, SNAPSHOT= {}, {}, {}
-
-    def index
-      @responses = {}
 
-      RESPONSES.each do |name, responses|
-        responses.each do |pattern, response|
-          pattern = pattern.is_a?(Regexp) ? "pattern = #{pattern.source}" : ''
-          delay = response.delay > 0 ? "delay = #{response.delay}" : ''
-          pattern << ' ,' unless pattern.empty? || delay.empty?
-          @responses["#{name}#{'/*' if response.default?}: #{pattern} #{delay}"] = response
-        end
-      end
+    delete '/mirage/requests' do
+      REQUESTS.clear
     end
 
-    def peek response_id
-      peeked_response = nil
-      RESPONSES.values.each do |responses|
-        peeked_response = responses.values.find { |response| response.response_id == response_id.to_i }
-        break unless peeked_response.nil?
-      end
-      respond("Can not peek reponse, id:#{response_id} does not exist}", 404) unless peeked_response
-      send_response(peeked_response)
+    delete '/mirage/requests/:id' do
+      REQUESTS.delete(params[:id].to_i)
     end
 
-    def set *args
-      delay = (request['delay']||0)
-      pattern = request['pattern'] ? /#{request['pattern']}/ : :basic
-      name = args.join('/')
-      is_default = request['default'] == 'true'
-
-      response = MockResponse.new(name, response_value, pattern, delay.to_f, is_default)
 
-      stored_responses = RESPONSES[name]||={}
-
-      old_response = stored_responses.delete(pattern)
-      stored_responses[pattern] = response
-
-      # Right not an the main id count goes up by one even if the id is not used because the old id is reused from another response
-      response.response_id = old_response.response_id if old_response
-      response.response_id
+    delete '/mirage/templates' do
+      [REQUESTS].each { |map| map.clear }
+      MOCK_RESPONSES.clear
+      MockResponse.reset_count
     end
 
-    def get *args
-      body, query_string = Rack::Utils.unescape(request.body.read.to_s), request.env['QUERY_STRING']
-      name = args.join('/')
-      stored_responses = RESPONSES[name]
-
-      if stored_responses
-        record = find_response(body, query_string, stored_responses)
-      else
-        default_responses, record = find_default_responses(name), nil
+    get '/mirage/templates/:id' do
+      response = MOCK_RESPONSES.find(params[:id].to_i)
+      return 404 if response.is_a? Array
+      send_response(response)
+    end
 
-        until record  || default_responses.empty?
-          record = find_response(body, query_string, default_responses.delete_at(0))
-          record = record.default? ? record : nil
-        end
-      end
+    get '/mirage/requests/:id' do
+      REQUESTS[params[:id].to_i] || 404
+    end
 
-      respond('Response not found', 404) unless record
-      REQUESTS[record.response_id] = body.empty? ? query_string : body
 
-      sleep record.delay
-      send_response(record, body, request, query_string)
-    end
+    get '/mirage' do
+      @responses = {}
 
-    def clear datatype=nil, response_id=nil
-      response_id = response_id.to_i
-      case datatype
-        when 'requests' then
-          REQUESTS.clear
-        when 'responses' then
-          RESPONSES.clear and REQUESTS.clear and MockResponse.reset_count
-        when /\d+/ then
-          response_id = datatype.to_i
-          delete_response(response_id)
-          REQUESTS.delete(response_id)
-        when 'request'
-          REQUESTS.delete(response_id)
-        when nil
-          [REQUESTS, RESPONSES].each { |map| map.clear }
-          MockResponse.reset_count
+      MOCK_RESPONSES.all.each do |response|
+        pattern = response.pattern.is_a?(Regexp) ? "pattern = #{response.pattern.source}" : ''
+        delay = response.delay > 0 ? "delay = #{response.delay}" : ''
+        pattern << ' ,' unless pattern.empty? || delay.empty?
+        @responses["#{response.name}#{'/*' if response.default?}: #{pattern} #{delay}"] = response
       end
+      erb :index
     end
 
-    def track id
-      REQUESTS[id.to_i] || respond("Nothing stored for: #{id}", 404)
+    error do
+      erb request.env['sinatra.error'].message
     end
 
-    def save
-      SNAPSHOT.clear and SNAPSHOT.replace(RESPONSES.deep_clone)
-    end
-
-    def revert
-      RESPONSES.clear and RESPONSES.replace(SNAPSHOT.deep_clone)
-    end
+    put '/mirage/defaults' do
+      MOCK_RESPONSES.clear
 
-    def prime
-      clear
       Dir["#{DEFAULT_RESPONSES_DIR}/**/*.rb"].each do |default|
         begin
           load default
         rescue Exception
-          respond("Unable to load default responses from: #{default}", 500)
+          raise "Unable to load default responses from: #{default}"
         end
 
       end
     end
-
-    private
-    def find_response(body, query_string, stored_responses)
-      pattern_match = stored_responses.keys.find_all { |pattern| pattern != :basic }.find { |pattern| body =~ pattern || query_string =~ pattern }
-      record = pattern_match ? stored_responses[pattern_match] : stored_responses[:basic]
-      record
+#
+    put '/mirage/backup' do
+      MOCK_RESPONSES.backup
     end
 
-    def response_value
-      return request['response'] unless request['response'].nil?
-      respond('response or file parameter required', 500)
-    end
 
-    def find_default_responses(name)
-      matches = RESPONSES.keys.find_all { |key| name.index(key) == 0 }.sort { |a, b| b.length <=> a.length }
-      matches.collect { |key| RESPONSES[key] }
+    put '/mirage' do
+      MOCK_RESPONSES.revert
     end
 
-    def delete_response(response_id)
-      RESPONSES.values.each do |response_set|
-        response_set.each { |key, response| response_set.delete(key) if response.response_id == response_id }
+
+    helpers do
+
+      def response_value
+        return request['response'] unless request['response'].nil?
       end
-    end
 
-    def send_response(response, body='', request={}, query_string='')
-      if response.file?
-        tempfile, filename, type = response.value.values_at(:tempfile, :filename, :type)
-        tempfile.binmode
-        send_file(tempfile.path, type, "Content-Length: #{tempfile.size}; Content-Disposition: attachment; filename=#{filename}")
-      else
+      def send_response(response, body='', request={}, query_string='')
+        content_type(response.content_type)
         response.value(body, request, query_string)
       end
     end
-
   end
 end