lib/webmock/response.rb in webmock-0.9.1 vs lib/webmock/response.rb in webmock-1.0.0

@@ -2,83 +2,139 @@
 class StringIO
   alias_method :read_nonblock, :sysread
 end
 
 module WebMock
+
+  class ResponseFactory
+    def self.response_for(options)
+      if options.respond_to?(:call)
+        WebMock::DynamicResponse.new(options)
+      else
+        WebMock::Response.new(options)
+      end
+    end
+  end
   
   class Response
-    attr_reader :options
-
     def initialize(options = {})
-      if options.is_a?(IO) || options.is_a?(String) 
-          self.options = read_raw_response(options)
-        else
-          self.options = options
+      if options.is_a?(IO) || options.is_a?(String)
+        self.options = read_raw_response(options)
+      else
+        self.options = options
       end
-      @options[:headers] = Util::Headers.normalize_headers(@options[:headers]) unless @options[:headers].is_a?(Proc)
     end
 
     def headers
-      @options[:headers]
+      @headers
     end
+    
+    def headers=(headers)
+      @headers = headers
+      if @headers && !@headers.is_a?(Proc)
+        @headers = Util::Headers.normalize_headers(@headers)
+      end
+    end
 
     def body
-      return '' unless @options.has_key?(:body)
+      @body || ''
+    end
+    
+    def body=(body)
+      @body = body
       stringify_body!
-      @options[:body]
     end
 
     def status
-      @options.has_key?(:status) ? @options[:status] : 200
+      @status || [200, ""]
     end
 
+    def status=(status)
+      @status = status.is_a?(Integer) ? [status, ""] : status
+    end
+
+    def exception
+      @exception
+    end
+
     def raise_error_if_any
-      raise @options[:exception].new('Exception from WebMock') if @options.has_key?(:exception)
+      raise @exception.new('Exception from WebMock') if @exception
     end
 
+    def should_timeout
+      @should_timeout == true
+    end
+
     def options=(options)
-      @options = options
-      stringify_body!
+      self.headers = options[:headers]
+      self.status = options[:status]
+      self.body = options[:body]
+      @exception = options[:exception]
+      @should_timeout = options[:should_timeout]
     end
 
-    def dup
-      dup_response = super
-      dup_response.options = options.dup
-      dup_response
+    def evaluate!(request_signature)
+      self.body = @body.call(request_signature) if @body.is_a?(Proc)
+      self.headers = @headers.call(request_signature) if @headers.is_a?(Proc)
+      self.status = @status.call(request_signature) if @status.is_a?(Proc)
+      @should_timeout = @should_timeout.call(request_signature) if @should_timeout.is_a?(Proc)
+      @exception = @exception.call(request_signature) if @exception.is_a?(Proc)
+      self
     end
 
     def ==(other)
-      options == other.options
+      self.body == other.body &&
+      self.headers === other.headers &&
+      self.status == other.status &&
+      self.exception == other.exception &&
+      self.should_timeout == other.should_timeout
     end
-    
-    private 
 
+    private
+
     def stringify_body!
-      if @options[:body].is_a?(IO)
-        io = @options[:body]
-        @options[:body] = io.read
+      if @body.is_a?(IO)
+        io = @body
+        @body = io.read
         io.close
       end
     end
-    
+
     def read_raw_response(raw_response)
       if raw_response.is_a?(IO)
-        string = raw_response.read 
+        string = raw_response.read
         raw_response.close
         raw_response = string
-      end        
-      socket = Net::BufferedIO.new(raw_response)    
+      end
+      socket = Net::BufferedIO.new(raw_response)
       response = Net::HTTPResponse.read_new(socket)
       transfer_encoding = response.delete('transfer-encoding') #chunks were already read by curl
       response.reading_body(socket, true) {}
-      
+
       options = {}
       options[:headers] = {}
       response.each_header {|name, value| options[:headers][name] = value}
       options[:headers]['transfer-encoding'] = transfer_encoding if transfer_encoding
       options[:body] = response.read_body
-      options[:status] = response.code.to_i
-      options      
+      options[:status] = [response.code.to_i, response.message]
+      options
     end
 
+  end
+
+  class DynamicResponse < Response
+    attr_accessor :responder
+
+    def initialize(responder)
+      @responder = responder
+    end
+
+    def dup
+      self.class.new(@responder)
+    end
+
+    def evaluate!(request_signature)
+      self.options = @responder.call(request_signature)
+      self
+    end
   end
 end