webmock 0.9.1 → 1.0.0

data/lib/webmock/request_execution_verifier.rb

@@ -1,22 +1,22 @@
 module WebMock
   class RequestExecutionVerifier
 
-    attr_accessor :request_profile, :expected_times_executed, :times_executed
+    attr_accessor :request_pattern, :expected_times_executed, :times_executed
 
-    def initialize(request_profile = nil, expected_times_executed = nil)
-      @request_profile = request_profile
+    def initialize(request_pattern = nil, expected_times_executed = nil)
+      @request_pattern = request_pattern
       @expected_times_executed = expected_times_executed
     end
 
     def matches?
       @times_executed =
-      RequestRegistry.instance.times_executed(@request_profile)
+      RequestRegistry.instance.times_executed(@request_pattern)
       @times_executed == (@expected_times_executed || 1)
     end
 
     def does_not_match?
       @times_executed =
-      RequestRegistry.instance.times_executed(@request_profile)
+      RequestRegistry.instance.times_executed(@request_pattern)
       if @expected_times_executed
         @times_executed != @expected_times_executed
       else
@@ -27,14 +27,14 @@ module WebMock
 
     def failure_message
       expected_times_executed = @expected_times_executed || 1
-      %Q(The request #{request_profile.to_s} was expected to execute #{expected_times_executed} time#{ (expected_times_executed == 1) ? '' : 's'} but it executed #{times_executed} time#{ (times_executed == 1) ? '' : 's'})
+      %Q(The request #{request_pattern.to_s} was expected to execute #{expected_times_executed} time#{ (expected_times_executed == 1) ? '' : 's'} but it executed #{times_executed} time#{ (times_executed == 1) ? '' : 's'})
     end
 
     def negative_failure_message
       if @expected_times_executed
-        %Q(The request #{request_profile.to_s} was not expected to execute #{expected_times_executed} time#{ (expected_times_executed == 1) ? '' : 's'} but it executed #{times_executed} time#{ (times_executed == 1) ? '' : 's'})
+        %Q(The request #{request_pattern.to_s} was not expected to execute #{expected_times_executed} time#{ (expected_times_executed == 1) ? '' : 's'} but it executed #{times_executed} time#{ (times_executed == 1) ? '' : 's'})
       else
-        %Q(The request #{request_profile.to_s} was expected to execute 0 times but it executed #{times_executed} time#{ (times_executed == 1) ? '' : 's'})
+        %Q(The request #{request_pattern.to_s} was expected to execute 0 times but it executed #{times_executed} time#{ (times_executed == 1) ? '' : 's'})
       end
     end
 

data/lib/webmock/request_pattern.rb

@@ -0,0 +1,130 @@
+module WebMock
+
+  class RequestPattern
+
+    def initialize(method, uri, options = {})
+      @method_pattern = MethodPattern.new(method)
+      @uri_pattern = URIPattern.new(uri)
+      assign_options(options)
+    end
+
+    def with(options = {}, &block)
+      assign_options(options)
+      @with_block = block
+      self
+    end
+
+    def matches?(request_signature)
+      @method_pattern.matches?(request_signature.method) &&
+      @uri_pattern.matches?(request_signature.uri) &&
+      (@body_pattern.nil? || @body_pattern.matches?(request_signature.body)) &&
+      (@headers_pattern.nil? || @headers_pattern.matches?(request_signature.headers)) &&
+      (@with_block.nil? || @with_block.call(request_signature))
+    end
+
+    def to_s
+      string = "#{@method_pattern.to_s.upcase}"
+      string << " #{@uri_pattern.to_s}"
+      string << " with body '#{@body_pattern.to_s}'" if @body_pattern
+      string << " with headers #{@headers_pattern.to_s}" if @headers_pattern
+      string << " with given block" if @with_block
+      string
+    end
+
+    private
+
+
+    def assign_options(options)
+      @body_pattern = BodyPattern.new(options[:body]) if options.has_key?(:body)
+      @headers_pattern = HeadersPattern.new(options[:headers]) if options.has_key?(:headers)
+    end
+
+  end
+  
+
+  class MethodPattern
+    def initialize(pattern)
+      @pattern = pattern
+    end
+
+    def matches?(method)
+      @pattern == method || @pattern == :any
+    end
+
+    def to_s
+      @pattern.to_s
+    end
+  end
+
+  class URIPattern
+    def initialize(pattern)
+      @pattern = pattern.is_a?(Addressable::URI) ? pattern : WebMock::Util::URI.normalize_uri(pattern)
+    end
+
+    def matches?(uri)
+      if @pattern.is_a?(Addressable::URI)
+        ##TODO : do I need to normalize again??
+        WebMock::Util::URI.normalize_uri(uri) === WebMock::Util::URI.normalize_uri(@pattern)
+      elsif @pattern.is_a?(Regexp)
+        WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u| u.match(@pattern) }
+      else
+        false
+      end
+    end
+
+    def to_s
+      WebMock::Util::URI.strip_default_port_from_uri_string(@pattern.to_s)
+    end
+  end
+
+  class BodyPattern
+    def initialize(pattern)
+      @pattern = pattern
+    end
+
+    def matches?(uri)
+      empty_string?(@pattern) && empty_string?(uri) ||
+        @pattern == uri ||
+        @pattern === uri
+    end
+    
+    def to_s
+      @pattern.to_s
+    end
+
+    private
+
+    def empty_string?(string)
+      string.nil? || string == ""
+    end
+  end
+
+  class HeadersPattern
+    def initialize(pattern)
+      @pattern = WebMock::Util::Headers.normalize_headers(pattern) || {}
+    end
+
+    def matches?(headers)
+      if empty_headers?(@pattern)
+        empty_headers?(headers)
+      else
+        return false if empty_headers?(headers)
+        @pattern.each do |key, value|
+          return false unless headers.has_key?(key) && value === headers[key]
+        end
+        true
+      end
+    end
+    
+    def to_s
+      WebMock::Util::Headers.sorted_headers_string(@pattern)
+    end
+
+    private
+
+    def empty_headers?(headers)
+      headers.nil? || headers == {}
+    end
+  end
+
+end

data/lib/webmock/request_registry.rb

@@ -28,9 +28,9 @@ module WebMock
       stub ? evaluate_response_for_request(stub.response, request_signature) : nil
     end
 
-    def times_executed(request_profile)
+    def times_executed(request_pattern)
       self.requested_signatures.hash.select { |request_signature, times_executed|
-        request_signature.match(request_profile)
+        request_pattern.matches?(request_signature)
       }.inject(0) {|sum, (_, times_executed)| sum + times_executed }
     end
 
@@ -38,18 +38,13 @@ module WebMock
 
     def request_stub_for(request_signature)
       request_stubs.detect { |registered_request_stub|
-        request_signature.match(registered_request_stub.request_profile)
+        registered_request_stub.request_pattern.matches?(request_signature)
       }
     end
 
     def evaluate_response_for_request(response, request_signature)
       evaluated_response = response.dup
-      [:body, :headers].each do |attribute|
-        if response.options[attribute].is_a?(Proc)
-          evaluated_response.options[attribute] = response.options[attribute].call(request_signature)
-        end
-      end
-      evaluated_response
+      evaluated_response.evaluate!(request_signature)
     end
 
   end

data/lib/webmock/request_signature.rb

@@ -1,51 +1,32 @@
 module WebMock
 
-  class RequestSignature < Request
-
-    def match(request_profile)
-      raise ArgumentError unless request_profile.is_a?(RequestProfile)
-      match_method(request_profile) &&
-        match_body(request_profile) &&
-        match_headers(request_profile) &&
-        match_uri(request_profile) &&
-        match_with_block(request_profile)
-    end
+  class RequestSignature
 
-    private
+    attr_accessor :method, :uri, :body, :headers
 
-    def match_uri(request_profile)
-      if request_profile.uri.is_a?(Addressable::URI)
-        WebMock::Util::URI.normalize_uri(uri) === WebMock::Util::URI.normalize_uri(request_profile.uri)
-      elsif request_profile.uri.is_a?(Regexp)
-        WebMock::Util::URI.variations_of_uri_as_strings(self.uri).any? { |u| u.match(request_profile.uri) }
-      else
-        false
-      end
+    def initialize(method, uri, options = {})
+      self.method = method
+      self.uri = uri.is_a?(Addressable::URI) ? uri : WebMock::Util::URI.normalize_uri(uri)
+      assign_options(options)
     end
 
-    def match_headers(request_profile)
-      return false if self.headers && !self.headers.empty? && request_profile.headers && request_profile.headers.empty?
-      if request_profile.headers && !request_profile.headers.empty?
-        request_profile.headers.each do | key, value |
-          return false unless (self.headers && self.headers.has_key?(key) && value === self.headers[key])
-        end
+    def to_s
+      string = "#{self.method.to_s.upcase}"
+      string << " #{WebMock::Util::URI.strip_default_port_from_uri_string(self.uri.to_s)}"
+      string << " with body '#{body.to_s}'" if body && body.to_s != ''
+      if headers && !headers.empty?
+        string << " with headers #{WebMock::Util::Headers.sorted_headers_string(headers)}"
       end
-      return true
+      string
     end
 
-    def match_body(request_profile)
-      request_profile.body == self.body || request_profile.body.nil?
-    end
+    private
 
-    def match_method(request_profile)
-      request_profile.method == self.method || request_profile.method == :any
-    end
-    
-    def match_with_block(request_profile)
-      return true unless request_profile.with_block
-      request_profile.with_block.call(self)
+    def assign_options(options)
+      self.body = options[:body] if options.has_key?(:body)
+      self.headers = WebMock::Util::Headers.normalize_headers(options[:headers]) if options.has_key?(:headers)
     end
-  end
 
+  end
 
 end

data/lib/webmock/request_stub.rb

@@ -1,26 +1,37 @@
 module WebMock
   class RequestStub
 
-    attr_accessor :request_profile, :responses
+    attr_accessor :request_pattern
 
     def initialize(method, uri)
-      @request_profile = RequestProfile.new(method, uri)
+      @request_pattern = RequestPattern.new(method, uri)
       @responses_sequences = []
       self
     end
 
     def with(params = {}, &block)
-      @request_profile.with(params, &block)
+      @request_pattern.with(params, &block)
       self
     end
 
-    def to_return(*response_hashes)
-      @responses_sequences << ResponsesSequence.new([*response_hashes].flatten.map {|r| WebMock::Response.new(r)})
+    def to_return(*response_hashes, &block)
+      if block
+        @responses_sequences << ResponsesSequence.new([ResponseFactory.response_for(block)])
+      else
+        @responses_sequences << ResponsesSequence.new([*response_hashes].flatten.map {|r| ResponseFactory.response_for(r)})
+      end
       self
     end
 
     def to_raise(*exceptions)
-      @responses_sequences << ResponsesSequence.new([*exceptions].flatten.map {|e| WebMock::Response.new(:exception => e)})
+      @responses_sequences << ResponsesSequence.new([*exceptions].flatten.map {|e| 
+        ResponseFactory.response_for(:exception => e)
+      })
+      self
+    end
+    
+    def to_timeout
+      @responses_sequences << ResponsesSequence.new([ResponseFactory.response_for(:should_timeout => true)])
       self
     end
 

data/lib/webmock/response.rb

@@ -4,81 +4,137 @@ class StringIO
 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