mirage 2.4.2 → 3.0.0.alpha.1

data/mirage_server.rb

@@ -4,17 +4,13 @@ $LOAD_PATH.unshift("#{ROOT_DIR}/lib")
 $LOAD_PATH.unshift("#{ROOT_DIR}/server")
 
 require 'sinatra/base'
-
 require 'extensions/object'
 require 'extensions/hash'
-require 'mock_response'
-
+require 'app'
 require 'mirage/client'
 
 module Mirage
-
   class Server < Sinatra::Base
-
     configure do
       options = Hash[*ARGV]
       set :defaults, options["defaults"]
@@ -31,136 +27,6 @@ module Mirage
       use Rack::CommonLogger, log_file
       enable :logging
     end
-
-    REQUESTS= {}
-
-    put '/mirage/templates/*' do |name|
-      response = request.body.read
-
-      MockResponse.new(name,
-                       response,
-                       :content_type => @env['CONTENT_TYPE'],
-                       :http_method => @env['HTTP_X_MIRAGE_METHOD'],
-                       :status => @env['HTTP_X_MIRAGE_STATUS'],
-                       :pattern => @env['HTTP_X_MIRAGE_PATTERN'],
-                       :delay => @env['HTTP_X_MIRAGE_DELAY'].to_f,
-                       :default => @env['HTTP_X_MIRAGE_DEFAULT'],
-                       :file => @env['HTTP_X_MIRAGE_FILE']).response_id.to_s
-    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.query_string
-
-        begin
-          record = MockResponse.find(body, query_string, name, http_method)
-        rescue ServerResponseNotFound
-          record = MockResponse.find_default(body, http_method, name, query_string)
-        end
-
-        REQUESTS[record.response_id] = body.empty? ? query_string : body
-
-        send_response(record, body, request, query_string)
-      end
-    end
-
-    delete '/mirage/templates/:id' do
-      MockResponse.delete(response_id)
-      REQUESTS.delete(response_id)
-      200
-    end
-
-    delete '/mirage/requests' do
-      REQUESTS.clear
-      200
-    end
-
-    delete '/mirage/requests/:id' do
-      REQUESTS.delete(response_id)
-      200
-    end
-
-    delete '/mirage/templates' do
-      REQUESTS.clear
-      MockResponse.delete_all
-      200
-    end
-
-    get '/mirage/templates/:id' do
-      send_response(MockResponse.find_by_id(response_id))
-    end
-
-    get '/mirage/requests/:id' do
-      REQUESTS[response_id] || 404
-    end
-
-    get '/mirage' do
-      @responses = {}
-
-      MockResponse.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
-
-
-    put '/mirage/defaults' do
-      MockResponse.delete_all
-      if File.directory?(settings.defaults.to_s)
-        Dir["#{settings.defaults}/**/*.rb"].each do |default|
-          begin
-            eval File.read(default)
-          rescue Exception => e
-            raise "Unable to load default responses from: #{default}"
-          end
-        end
-      end
-      200
-    end
-#
-    put '/mirage/backup' do
-      MockResponse.backup
-      200
-    end
-
-
-    put '/mirage' do
-      MockResponse.revert
-      200
-    end
-
-    get '/mirage/pid' do
-      "#{$$}"
-    end
-
-    error ServerResponseNotFound do
-      404
-    end
-
-    error do
-      erb request.env['sinatra.error'].message
-    end
-
-    helpers do
-
-      def response_id
-        params[:id].to_i
-      end
-
-      def prime &block
-        yield Mirage::Client.new "http://localhost:#{settings.port}/mirage"
-      end
-
-      def send_response(response, body='', request={}, query_string='')
-        sleep response.delay
-        content_type(response.content_type)
-        status response.status
-        response.value(body, request, query_string)
-      end
-    end
   end
 end
 

data/rakefile

@@ -13,7 +13,25 @@ end
 require 'rake'
 require 'rspec/core/rake_task'
 
-RSpec::Core::RakeTask.new
+task :specs
+
+%w(client server).each do |type|
+  public_task_name = "#{type}_specs"
+  private_task_name = "_#{public_task_name}"
+
+  RSpec::Core::RakeTask.new(private_task_name) do |task|
+    task.pattern = "spec/#{type}/**/*_spec.rb"
+  end
+
+  desc "specs for: #{type}"
+  task public_task_name do
+    ENV['coverage'] = type
+    Rake::Task[private_task_name].invoke
+  end
+
+  Rake::Task["specs"].prerequisites << public_task_name
+end
+
 
 require 'jeweler'
 Jeweler::Tasks.new do |gem|
@@ -39,7 +57,7 @@ end
 Jeweler::RubygemsDotOrgTasks.new
 
 
-require 'cucumber'                                    
+require 'cucumber'
 require 'cucumber/rake/task'
 Cucumber::Rake::Task.new(:features) do |t|
   t.cucumber_opts = "mode=regression features --format pretty"
@@ -50,7 +68,7 @@ task :clean do |task|
     puts "cleaning"
     system "gem uninstall -x mirage"
   end
-  Dir['*.gem'].each{|gem| FileUtils.rm_f(gem)}
+  Dir['*.gem'].each { |gem| FileUtils.rm_f(gem) }
   task.reenable
 end
 
@@ -62,7 +80,4 @@ task :stop do
   `RACK_ENV='development' && ruby ./bin/mirage stop`
 end
 
-
-
-
-task :default => [:spec, :install,:features,:clean]
+task :default => [:specs, :install, :features, :clean]

data/server/app.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'sinatra'
+require 'mock_response'
+require 'server'

data/server/binary_data_checker.rb

@@ -0,0 +1,15 @@
+require 'ptools'
+module Mirage
+  module BinaryDataChecker
+      class << self
+        def contains_binary_data? string
+          tmpfile = Tempfile.new("binary_check")
+          tmpfile.write(string)
+          tmpfile.close
+          binary = File.binary?(tmpfile.path)
+          FileUtils.rm(tmpfile.path)
+          binary
+        end
+      end
+  end
+end

data/server/helpers.rb

@@ -0,0 +1,28 @@
+require 'tempfile'
+require 'ptools'
+module Mirage
+  class Server < Sinatra::Base
+    module Helpers
+      def convert_raw_required_params raw_requirements
+        raw_requirements.collect { |requirement| requirement.split(":") }.inject({}) do |hash, pair|
+          parameter, value = pair.collect { |string| string.strip }
+          value = convert_value(value)
+          hash[parameter] =value; hash
+        end
+      end
+
+      def convert_raw_required_body_content_requirements raw_requirements
+        raw_requirements.collect do |string|
+          string.start_with?("%r{") && string.end_with?("}") ? eval(string) : string
+        end
+      end
+
+
+
+      private
+      def convert_value(value)
+        value.start_with?("%r{") && value.end_with?("}") ? eval(value) : value
+      end
+    end
+  end
+end

data/server/mock_response.rb

@@ -1,16 +1,25 @@
+require 'binary_data_checker'
+require 'hashie/mash'
 module Mirage
   class ServerResponseNotFound < Exception
-    
+
+  end
+
+  class MalformedResponse < Exception
+
   end
+
   class MockResponse
     class << self
 
-      def find_by_id id
-        response_set_containing(id).values.find { |response| response.response_id == id } || raise(ServerResponseNotFound)
+      def find_by_id(id)
+        all.find{|response| response.response_id == id} || raise(ServerResponseNotFound)
       end
 
       def delete(id)
-        response_set_containing(id).delete_if { |http_method, response| response.response_id == id }
+        responses.values.each do |set|
+          set.values.each{|responses| responses.delete_if{|response|response.response_id == id}}
+        end
       end
 
       def delete_all
@@ -18,6 +27,7 @@ module Mirage
         @next_id = 0
       end
 
+      #TODO - this is flakey, make a proper copy
       def backup
         snapshot.clear and snapshot.replace(responses.deep_clone)
       end
@@ -27,63 +37,100 @@ module Mirage
       end
 
       def all
-        all_responses = []
-        response_sets.each do |response_set|
-          response_set.values.each{|response|all_responses << response}
-        end
-        all_responses
+        responses.values.collect do|response_set|
+          response_set.values
+        end.flatten
       end
 
-      def find_default(body, http_method, name, query_string)
-        default_response_sets = find_default_responses(name)
-
-        until default_response_sets.empty?
-          record = find_in_response_set(body, query_string, default_response_sets.delete_at(0), http_method)
-          return record if record && record.default?
-        end
+      def find_default(options)
+       http_method = options[:http_method].upcase!
+        default_responses = subdomains(options[:endpoint]).collect do |domain|
+          if(responses_for_domain = responses[domain])
+            responses_for_domain[http_method].find_all{|response| response.default?} if responses_for_domain[http_method]
+          end
+        end.flatten.compact
 
-        raise ServerResponseNotFound
+        default_responses.find{|response| match?(options,response)} || raise(ServerResponseNotFound)
       end
 
-      def find(body, query_string, name, http_method)
-        find_in_response_set(body, query_string, responses[name], http_method) || raise(ServerResponseNotFound)
+      def subdomains(name)
+        domains=[]
+        name.split("/").each do |part|
+          domains << (domains.last ? "#{domains.last}/#{part}" : part)
+        end
+        domains.reverse
       end
 
-      def add new_response
-        response_set = target_response_set(new_response)
+      def find(options)
+        options[:response_set] = responses[options[:endpoint]]
+        find_in_response_set(options) || raise(ServerResponseNotFound)
+      end
 
-        old_response = response_set.delete(new_response.http_method)
-        response_set[new_response.http_method] = new_response
-        new_response.response_id = old_response ? old_response.response_id : next_id
+      def add(new_response)
+        response_set = responses_for_endpoint(new_response)
+        method_specific_responses = response_set[new_response.request_spec['http_method'].upcase]||=[]
+        old_response = method_specific_responses.delete_at(method_specific_responses.index(new_response)) if method_specific_responses.index(new_response)
+        if old_response
+          new_response.response_id = old_response.response_id
+        else
+          new_response.response_id = next_id
+        end
+        method_specific_responses<<new_response
       end
 
       private
-
-      def find_in_response_set(body, query_string, response_set, http_method)
+      def find_in_response_set(options)
+        response_set = options.delete(:response_set)
         return unless response_set
-        response_set = response_set[body] || response_set[query_string] || response_set[:basic]
-        response_set[http_method.upcase] if response_set
-      end
 
-      def response_set_containing id
-        response_sets.each do |response_set|
-          return response_set if response_set.find { |key, response| response.response_id == id }
+        responses_for_http_method = response_set[options[:http_method].upcase] || []
+
+        responses = responses_for_http_method.find_all do |stored_response|
+          match?(options, stored_response)
         end
-        {}
+
+        responses.sort{|a, b| b.score <=> a.score}.first
+
       end
 
-      def response_sets
-        responses.values.collect { |response_sets| response_sets.values }.flatten
+      def match?(options,stored_response)
+        parameters = options[:params]
+        headers = Hash[options[:headers].collect{|key, value| [key.downcase, value]}]
+
+        request_spec = stored_response.request_spec
+
+        match = true
+
+        {request_spec['parameters'] => parameters,
+         request_spec['headers'] => headers}.each do |spec, actual|
+          spec.each do |key, value|
+            value = interpret_value(value)
+            if value.is_a? Regexp
+              match = false unless value.match(actual[key])
+            else
+              match = false unless value == actual[key]
+            end
+          end
+        end
+
+        request_spec['body_content'].each do |value|
+          value = interpret_value(value)
+          if value.is_a? Regexp
+            match = false unless options[:body] =~ value
+          else
+            match = false unless options[:body].include?(value)
+          end
+        end
+
+        match
       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] }
+      def interpret_value(value)
+        value.start_with?("%r{") && value.end_with?("}") ? eval(value) : value
       end
 
-      def target_response_set response
-        responses_sets = responses[response.name]||={}
-        responses_sets[response.pattern] ||= {}
+      def responses_for_endpoint(response)
+        responses[response.name]||={}
       end
 
       def responses
@@ -98,40 +145,57 @@ module Mirage
         @next_id||= 0
         @next_id+=1
       end
-
     end
 
-    attr_reader  :name
-    attr_accessor :response_id
+    attr_reader :name, :request_spec, :response_spec
+    attr_accessor :response_id, :requests_url
+
+    def initialize name, spec={}
+
+      request_defaults = JSON.parse({:parameters => {},
+                                     :body_content => [],
+                                     :http_method => 'get',
+                                    :headers => {}}.to_json)
+      response_defaults = JSON.parse({:default => false,
+                                      :body => Base64.encode64(''),
+                                      :delay => 0,
+                                      :content_type => "text/plain",
+                                      :status => 200}.to_json)
+
+      @name = name
+      @spec = spec
+
+      @request_spec = Hashie::Mash.new request_defaults.merge(spec['request']||{})
+      @response_spec = Hashie::Mash.new response_defaults.merge(spec['response']||{})
+
+      @request_spec['headers'] = Hash[@request_spec['headers'].collect{|key, value| [key.downcase, value]}]
+      @binary = BinaryDataChecker.contains_binary_data? @response_spec['body']
 
-    def initialize name, value,options
-      @name, @value = name, value
-      @options = {:pattern => :basic, :http_method => 'GET', :delay => 0.0, :status => 200}.merge(options){|key, old_value, new_value| new_value || old_value}
-      @options[:http_method].upcase!
       MockResponse.add self
     end
 
-    def method_missing *args
-      method_name = args.first
-      key = method_name.to_s.gsub(/\?$/, '').to_sym
-      method_name.to_s.end_with?('?') ? 'true' == @options[key] : @options[key]
+    def default?
+      @response_spec["default"]
     end
 
-    def pattern
-      @options[:pattern] == :basic ? :basic : /#{@options[:pattern]}/
+    def score
+      [@request_spec['headers'].values, @request_spec['parameters'].values, @request_spec['body_content']].inject(0) do |score, matchers|
+        matchers.inject(score){|matcher_score, value| interpret_value(value).is_a?(Regexp) ? matcher_score+=1 : matcher_score+=2}
+      end
     end
 
-    def value(body='', request_parameters={}, query_string='')
-      return @value if file?
+    def value(request_body='', request_parameters={}, query_string='')
+      body = Base64.decode64(response_spec['body'])
+      return body if @binary
 
-      value = @value
+      value = body.dup
       value.scan(/\$\{([^\}]*)\}/).flatten.each do |pattern|
 
         if (parameter_match = request_parameters[pattern])
           value = value.gsub("${#{pattern}}", parameter_match)
         end
 
-        [body, query_string].each do |string|
+        [request_body, query_string].each do |string|
           if (string_match = find_match(string, pattern))
             value = value.gsub("${#{pattern}}", string_match)
           end
@@ -141,9 +205,27 @@ module Mirage
       value
     end
 
+    def == response
+      response.is_a?(MockResponse) && @name == response.send(:eval, "@name") && @request_spec == response.send(:eval, "@request_spec") && @response_spec == response.send(:eval, "@response_spec")
+    end
+
+    def raw
+      {:id =>response_id, :endpoint => @name, :requests_url => requests_url, :response => @response_spec, :request => @request_spec}.to_json
+    end
+
+    def binary?
+      @binary
+    end
+
     private
     def find_match(string, regex)
       string.scan(/#{regex}/).flatten.first
     end
+
+    def interpret_value(value)
+      value.start_with?("%r{") && value.end_with?("}") ? eval(value) : value
+    end
+
+
   end
 end