server/mock_response.rb in mirage-2.0.9 vs server/mock_response.rb in mirage-2.0.10

@@ -1,64 +1,67 @@
 module Mirage
+  class ServerResponseNotFound < Exception
+    
+  end
   class MockResponse
     class << self
 
-      def add response
-        stored_response_sets = responses[response.name]||={}
-        stored_response_set = (stored_response_sets[response.pattern] ||= {})
-
-        old_response = stored_response_set.delete(response.http_method)
-        stored_response_set[response.http_method] = response
-
-        response.response_id = old_response ? old_response.response_id : next_id
+      def find_by_id id
+        response_set_containing(id).values.find { |response| response.response_id == id } || raise(ServerResponseNotFound)
       end
 
-
-      def get_response name, http_method, body, query_string
-        find_response(body, query_string, responses[name], http_method) || default_response(body, http_method, name, query_string)
-      end
-
-      def find id
-        response_set_containing(id).values.find { |response| response.response_id == id }
-      end
-
       def delete(id)
         response_set_containing(id).delete_if { |http_method, response| response.response_id == id }
       end
 
-      def clear
+      def delete_all
         responses.clear
         @next_id = 0
       end
 
       def backup
         snapshot.clear and snapshot.replace(responses.deep_clone)
       end
 
       def revert
-        clear and responses.replace(snapshot.deep_clone)
+        delete_all and responses.replace(snapshot.deep_clone)
       end
 
       def all
         all_responses = []
         response_sets.each do |response_set|
           response_set.values.each{|response|all_responses << response}
         end
         all_responses
       end
 
-      def default_response(body, http_method, name, query_string)
+      def find_default(body, http_method, name, query_string)
         default_response_sets = find_default_responses(name)
 
         until default_response_sets.empty?
-          record = find_response(body, query_string, default_response_sets.delete_at(0), http_method)
+          record = find_in_response_set(body, query_string, default_response_sets.delete_at(0), http_method)
           return record if record && record.default?
         end
+
+        raise ServerResponseNotFound
       end
 
+      def find(body, query_string, name, http_method)
+        find_in_response_set(body, query_string, responses[name], http_method) || raise(ServerResponseNotFound)
+      end
+
+      def add new_response
+        response_set = target_response_set(new_response)
+
+        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
+      end
+
       private
-      def find_response(body, query_string, response_set, http_method)
+
+      def find_in_response_set(body, query_string, response_set, http_method)
         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
 
@@ -76,10 +79,15 @@
       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] }
       end
 
+      def target_response_set response
+        responses_sets = responses[response.name]||={}
+        responses_sets[response.pattern] ||= {}
+      end
+
       def responses
         @responses ||={}
       end
 
       def snapshot
@@ -95,11 +103,12 @@
 
     attr_reader :response_id, :delay, :name, :pattern, :http_method, :content_type
     attr_accessor :response_id
 
     def initialize name, value, content_type, http_method, pattern=nil, delay=0, default=false, file=false
-      @name, @value, @content_type, @http_method, @pattern, @delay, @default, @file = name, value, content_type, http_method.to_s.upcase, pattern, delay, default, file
+      @name, @value, @content_type, @http_method, @delay, @default, @file = name, value, content_type, (http_method||'GET').upcase,  delay, default, file
+      @pattern = pattern ? /#{pattern}/ : :basic
       MockResponse.add self
     end
 
     def default?
       'true' == @default
@@ -133,6 +142,6 @@
     private
     def find_match(string, regex)
       string.scan(/#{regex}/).flatten.first
     end
   end
-end
+end
\ No newline at end of file