webmock 1.2.2 → 1.3.0

data/lib/webmock/http_lib_adapters/net_http_response.rb

@@ -0,0 +1,49 @@
+# This code is entierly copied from VCR (http://github.com/myronmarston/vcr) by courtesy of Myron Marston  
+
+# A Net::HTTP response that has already been read raises an IOError when #read_body
+# is called with a destination string or block.
+#
+# This causes a problem when VCR records a response--it reads the body before yielding
+# the response, and if the code that is consuming the HTTP requests uses #read_body, it
+# can cause an error.
+#
+# This is a bit of a hack, but it allows a Net::HTTP response to be "re-read"
+# after it has aleady been read.  This attemps to preserve the behavior of
+# #read_body, acting just as if it had never been read.
+
+module WebMock
+  module Net
+    module HTTPResponse
+      def self.extended(object)
+        body_object = object.instance_variable_get(:@body)
+        object.instance_variable_set(:@__orig_body__,
+          case body_object
+            when String then body_object
+            else raise ArgumentError.new("Unexpected body object: #{body_object}")
+          end
+        )
+      end
+
+      def read_body(dest = nil, &block)
+        if @__orig_body__
+          if dest && block
+            raise ArgumentError.new("both arg and block given for HTTP method")
+          elsif dest
+            dest << @__orig_body__
+          elsif block
+            @body = ::Net::ReadAdapter.new(block)
+            @body << @__orig_body__
+            @body
+          else
+            @body = @__orig_body__
+          end
+        else
+          super
+        end
+      ensure
+        # allow subsequent calls to #read_body to proceed as normal, without our hack...
+        @__orig_body__ = nil
+      end
+    end
+  end
+end

data/lib/webmock/http_lib_adapters/patron.rb

@@ -11,9 +11,19 @@ if defined?(Patron)
         if WebMock.registered_request?(request_signature)
           webmock_response = WebMock.response_for_request(request_signature)
           handle_file_name(req, webmock_response)
-          build_patron_response(webmock_response)
+          res = build_patron_response(webmock_response)
+          WebMock::CallbackRegistry.invoke_callbacks(
+            {:lib => :patron}, request_signature, webmock_response)
+          res
         elsif WebMock.net_connect_allowed?(request_signature.uri)
-          handle_request_without_webmock(req)
+          res = handle_request_without_webmock(req)
+          if WebMock::CallbackRegistry.any_callbacks?
+            webmock_response = build_webmock_response(res)
+            WebMock::CallbackRegistry.invoke_callbacks(
+              {:lib => :patron, :real_request => true}, request_signature,
+                webmock_response)   
+          end
+          res
         else
           raise WebMock::NetConnectNotAllowedError.new(request_signature)
         end
@@ -37,7 +47,7 @@ if defined?(Patron)
       end
 
       def build_request_signature(req)
-        uri = Addressable::URI.heuristic_parse(req.url)
+        uri = WebMock::Util::URI.heuristic_parse(req.url)
         uri.path = uri.normalized_path.gsub("[^:]//","/")
         uri.user = req.username
         uri.password = req.password
@@ -74,6 +84,15 @@ if defined?(Patron)
         res.instance_variable_set(:@headers, webmock_response.headers)
         res
       end
+      
+      def build_webmock_response(patron_response)
+        webmock_response = WebMock::Response.new
+        reason = patron_response.status_line.scan(%r(\AHTTP/(\d+\.\d+)\s+(\d\d\d)\s*([^\r\n]+)?\r?\z))[0][2]
+        webmock_response.status = [patron_response.status, reason]
+        webmock_response.body = patron_response.body
+        webmock_response.headers = patron_response.headers
+        webmock_response
+      end
 
     end
   end

data/lib/webmock/request_pattern.rb

@@ -4,7 +4,7 @@ module WebMock
 
     def initialize(method, uri, options = {})
       @method_pattern = MethodPattern.new(method)
-      @uri_pattern = URIPattern.new(uri)
+      @uri_pattern = create_uri_pattern(uri)
       assign_options(options)
     end
 
@@ -15,17 +15,18 @@ module WebMock
     end
 
     def matches?(request_signature)
+      content_type = request_signature.headers['Content-Type'] if request_signature.headers
       @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))
+        @uri_pattern.matches?(request_signature.uri) &&
+        (@body_pattern.nil? || @body_pattern.matches?(request_signature.body, content_type || "")) &&
+        (@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 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
@@ -37,10 +38,19 @@ module WebMock
     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)
+      @uri_pattern.add_query_params(options[:query]) if options.has_key?(:query)
+    end
+    
+    def create_uri_pattern(uri)
+      if uri.is_a?(Regexp)
+        URIRegexpPattern.new(uri)
+      else
+        URIStringPattern.new(uri)
+      end
     end
 
   end
-  
+
 
   class MethodPattern
     def initialize(pattern)
@@ -56,40 +66,98 @@ module WebMock
     end
   end
 
+
   class URIPattern
     def initialize(pattern)
       @pattern = pattern.is_a?(Addressable::URI) ? pattern : WebMock::Util::URI.normalize_uri(pattern)
     end
+  end
+
+  class URIRegexpPattern  < URIPattern
+
+    def matches?(uri)
+      WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u| u.match(@pattern) } &&
+        (@query_params.nil? || @query_params == uri.query_values)
+    end
+
+    def to_s
+      str = @pattern.inspect
+      str += " with query params #{@query_params.inspect}" if @query_params
+      str
+    end
+
+    def add_query_params(query_params)
+      @query_params = query_params.is_a?(Hash) ? query_params : Addressable::URI.parse('?' + query_params).query_values
+    end
+
+  end
 
+  class URIStringPattern < URIPattern
     def matches?(uri)
       if @pattern.is_a?(Addressable::URI)
-        ##TODO : do I need to normalize again??
         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 add_query_params(query_params)
+      if !query_params.is_a?(Hash)
+        query_params = Addressable::URI.parse('?' + query_params).query_values
+      end
+      @pattern.query_values = (@pattern.query_values || {}).merge(query_params)
+    end
+
     def to_s
       WebMock::Util::URI.strip_default_port_from_uri_string(@pattern.to_s)
     end
+
   end
 
+
   class BodyPattern
+
+    BODY_FORMATS = {
+      'text/xml'               => :xml,
+      'application/xml'        => :xml,
+      'application/json'       => :json,
+      'text/json'              => :json,
+      'application/javascript' => :json,
+      'text/javascript'        => :json,
+      'text/html'              => :html,
+      'application/x-yaml'     => :yaml,
+      'text/yaml'              => :yaml,
+      'text/plain'             => :plain
+    }
+
     def initialize(pattern)
       @pattern = pattern
+      if (@pattern).is_a?(Hash)
+        @pattern = normalize_hash(@pattern)
+      end
     end
 
-    def matches?(uri)
-      empty_string?(@pattern) && empty_string?(uri) ||
-        @pattern == uri ||
-        @pattern === uri
+    def matches?(body, content_type = "")
+      if (@pattern).is_a?(Hash)
+        return true if @pattern.empty?
+
+        case BODY_FORMATS[content_type]
+        when :json then
+          Crack::JSON.parse(body) == @pattern
+        when :xml then
+          Crack::XML.parse(body) == @pattern
+        else
+          Addressable::URI.parse('?' + body).query_values == @pattern
+        end
+      else
+        empty_string?(@pattern) && empty_string?(body) ||
+          @pattern == body ||
+          @pattern === body
+      end
     end
-    
+
     def to_s
-      @pattern.to_s
+      @pattern.inspect
     end
 
     private
@@ -97,6 +165,11 @@ module WebMock
     def empty_string?(string)
       string.nil? || string == ""
     end
+
+    def normalize_hash(hash)
+      JSON.parse(JSON.generate(hash))
+    end
+
   end
 
   class HeadersPattern
@@ -115,7 +188,7 @@ module WebMock
         true
       end
     end
-    
+
     def to_s
       WebMock::Util::Headers.sorted_headers_string(@pattern)
     end

data/lib/webmock/response.rb

@@ -14,7 +14,7 @@ module WebMock
       end
     end
   end
-  
+
   class Response
     def initialize(options = {})
       if options.is_a?(IO) || options.is_a?(String)
@@ -27,7 +27,7 @@ module WebMock
     def headers
       @headers
     end
-    
+
     def headers=(headers)
       @headers = headers
       if @headers && !@headers.is_a?(Proc)
@@ -38,7 +38,7 @@ module WebMock
     def body
       @body || ''
     end
-    
+
     def body=(body)
       @body = body
       stringify_body!
@@ -56,8 +56,16 @@ module WebMock
       @exception
     end
 
+    def exception=(exception)
+      @exception = case exception
+      when String then StandardError.new(exception)
+      when Class then exception.new('Exception from WebMock')
+      when Exception then exception
+      end
+    end
+
     def raise_error_if_any
-      raise @exception.new('Exception from WebMock') if @exception
+      raise @exception if @exception
     end
 
     def should_timeout
@@ -68,7 +76,7 @@ module WebMock
       self.headers = options[:headers]
       self.status = options[:status]
       self.body = options[:body]
-      @exception = options[:exception]
+      self.exception = options[:exception]
       @should_timeout = options[:should_timeout]
     end
 
@@ -105,8 +113,8 @@ module WebMock
         raw_response.close
         raw_response = string
       end
-      socket = Net::BufferedIO.new(raw_response)
-      response = Net::HTTPResponse.read_new(socket)
+      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) {}
 

data/lib/webmock/util/uri.rb

@@ -11,15 +11,26 @@ module WebMock
   module Util
 
     class URI
+      ADDRESSABLE_URIS = Hash.new do |hash, key|
+        hash[key] = Addressable::URI.heuristic_parse(key)
+      end
+
+      NORMALIZED_URIS = Hash.new do |hash, uri|
+        normalized_uri = WebMock::Util::URI.heuristic_parse(uri)
+        normalized_uri.query_values = sort_query_values(normalized_uri.query_values) if normalized_uri.query_values
+        normalized_uri = normalized_uri.normalize #normalize! is slower
+        normalized_uri.port = normalized_uri.inferred_port unless normalized_uri.port
+        hash[uri] = normalized_uri
+      end
+
+      def self.heuristic_parse(uri)
+        ADDRESSABLE_URIS[uri].dup
+      end
 
       def self.normalize_uri(uri)
         return uri if uri.is_a?(Regexp)
         uri = 'http://' + uri unless uri.match('^https?://') if uri.is_a?(String)
-        normalized_uri = Addressable::URI.heuristic_parse(uri)
-        normalized_uri.query_values = sort_query_values(normalized_uri.query_values) if normalized_uri.query_values
-        normalized_uri = normalized_uri.normalize #normalize! is slower 
-        normalized_uri.port = normalized_uri.inferred_port unless normalized_uri.port
-        normalized_uri
+        NORMALIZED_URIS[uri].dup
       end
 
       def self.variations_of_uri_as_strings(uri_object)
@@ -35,7 +46,7 @@ module WebMock
         if normalized_uri.port == Addressable::URI.port_mapping[normalized_uri.scheme]
           uris = uris_with_inferred_port_and_without(uris)
         end
-        
+
         if normalized_uri.scheme == "http"
           uris = uris_with_scheme_and_without(uris)
         end
@@ -58,7 +69,7 @@ module WebMock
       private
 
       def self.sort_query_values(query_values)
-        Hash[*query_values.sort.inject([]) { |values, pair| values + pair}] 
+        Hash[*query_values.sort.inject([]) { |values, pair| values + pair}]
       end
 
       def self.uris_with_inferred_port_and_without(uris)

data/lib/webmock/webmock.rb

@@ -59,8 +59,16 @@ module WebMock
     WebMock::RequestRegistry.instance.reset_webmock
   end
 
+  def reset_callbacks
+    WebMock::CallbackRegistry.reset
+  end
+
   def assertion_failure(message)
     raise message
   end
+  
+  def after_request(options={}, &block)
+    CallbackRegistry.add_callback(options, block)
+  end
 
 end

data/spec/benchmark.rb

@@ -0,0 +1,61 @@
+# require 'rubygems'
+require 'benchmark'
+require 'net/http'
+# require 'fakeweb'
+require 'spec/spec_helper'
+
+def http_request
+  res = Net::HTTP.get_response(URI.parse('http://example.com'))
+  raise "Body should be 'Hello'" unless res.body == 'Hello'
+end
+
+def fakeweb
+  FakeWeb.register_uri(:get, 'http://example.com', :body => 'Hello')
+  yield
+ensure
+  FakeWeb.clean_registry
+end
+
+def webmock
+  WebMock.stub_request(:get, 'http://example.com').to_return(:body => 'Hello')
+  yield
+ensure
+  WebMock.reset_webmock
+end
+
+def perform_benchmark(name)
+  puts "\n\nBenchmarking #{name}:"
+  Benchmark.benchmark do |b|
+    %w(webmock).each do |type|
+      b.report(type) do
+        # this is a bit convoluted, but we want to ensure that each benchmark runs without the other library loaded,
+        # so we fork off a sub-process before requiring the libraries.
+        Process.fork do
+          require type
+          yield type
+        end
+        Process.wait
+      end
+    end
+  end
+end
+
+n = 5000
+perform_benchmark("Single setup/teardown") do |type|
+  send(type) { n.times { http_request } }
+end
+
+perform_benchmark("Setup/teardown for each http request") do |type|
+  n.times { send(type) { http_request } }
+end
+
+# Output on my machine:
+#
+# Benchmarking Single setup/teardown:
+# webmock  0.000000   0.000000  18.830000 ( 19.350281)
+# fakeweb  0.000000   0.000000   1.930000 (  2.049569)
+# 
+# 
+# Benchmarking Setup/teardown for each http request:
+# webmock  0.000000   0.000000  21.350000 ( 21.795557)
+# fakeweb  0.000000   0.000000   2.490000 (  2.707574)