webmock 0.7.1 → 0.7.2

data/lib/webmock/adapters/rspec/matchers.rb

@@ -8,12 +8,12 @@ module WebMock
       WebMock::RequestProfileMatcher.new.times(0)
     end
     
-    def have_requested(method, url)
-      WebMock::WebMockMatcher.new(method, url)
+    def have_requested(method, uri)
+      WebMock::WebMockMatcher.new(method, uri)
     end
     
-    def have_not_requested(method, url)
-      WebMock::WebMockMatcher.new(method, url).times(0)
+    def have_not_requested(method, uri)
+      WebMock::WebMockMatcher.new(method, uri).times(0)
     end
   end
 end

data/lib/webmock/adapters/rspec/webmock_matcher.rb

@@ -1,9 +1,9 @@
 module WebMock
   class WebMockMatcher
 
-    def initialize(method, url)
+    def initialize(method, uri)
       @request_execution_verifier = RequestExecutionVerifier.new
-      @request_execution_verifier.request_profile = RequestProfile.new(method, url)
+      @request_execution_verifier.request_profile = RequestProfile.new(method, uri)
     end
 
     def once

data/lib/webmock/adapters/test_unit.rb

@@ -1,25 +1,24 @@
-if defined?(Test::Unit::TestCase)
-  
-  class Test::Unit::TestCase
-    include WebMock
-    alias setup_without_webmock setup
-    def setup
-      reset_webmock
-      @original_allow_net_connect = WebMock.net_connect_allowed?
-      WebMock.disable_net_connect!
-    end
+require 'test/unit'
+require 'webmock'
 
-    alias teardown_without_webmock teardown
-    def teardown
-      @original_allow_net_connect ? WebMock.allow_net_connect! : WebMock.disable_net_connect!
-    end
+class Test::Unit::TestCase
+  alias setup_without_webmock setup
+  def setup
+    WebMock.reset_webmock
+    @original_allow_net_connect = WebMock.net_connect_allowed?
+    WebMock.disable_net_connect!
   end
-  
-  module WebMock
-    private
-    def assertion_failure(message)
-       raise Test::Unit::AssertionFailedError.new(message)
-    end
+
+  alias teardown_without_webmock teardown
+  def teardown
+    @original_allow_net_connect ? WebMock.allow_net_connect! : WebMock.disable_net_connect!
   end
-  
 end
+
+module WebMock
+  private
+  def assertion_failure(message)
+    raise Test::Unit::AssertionFailedError.new(message)
+  end
+end
+

data/lib/webmock/http_lib_adapters/net_http.rb

@@ -2,7 +2,6 @@ require 'net/http'
 require 'net/https'
 require 'stringio'
 
-
 class StubSocket #:nodoc:
 
   def initialize(*args)
@@ -61,11 +60,11 @@ module Net  #:nodoc: all
       protocol = use_ssl? ? "https" : "http"
 
       path = request.path
-      path = URI.parse(request.path).request_uri if request.path =~ /^http/
+      path = Addressable::URI.heuristic_parse(request.path).request_uri if request.path =~ /^http/
 
       if request["authorization"] =~ /^Basic /
-        userinfo = WebMock::Utility.decode_userinfo_from_header(request["authorization"])
-        userinfo = WebMock::Utility.encode_unsafe_chars_in_userinfo(userinfo) + "@"
+        userinfo = WebMock::Util::Headers.decode_userinfo_from_header(request["authorization"])
+        userinfo = WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo) + "@"
       else
         userinfo = ""
       end
@@ -74,24 +73,21 @@ module Net  #:nodoc: all
       method = request.method.downcase.to_sym
 
       headers = Hash[*request.to_hash.map {|k,v| [k, v.flatten]}.flatten]
-      headers.reject! {|k,v| k =~ /[Aa]ccept/ && v = '*/*'}
+      headers.reject! {|k,v| k =~ /[Aa]ccept/ && v = '*/*'} #removing header added by Net::HTTP
+
+      request_signature = WebMock::RequestSignature.new(method, uri, body, headers)
 
-      request_profile = WebMock::RequestProfile.new(method, uri, body, headers)
+      WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
 
-      if WebMock.registered_request?(request_profile)
+      if WebMock.registered_request?(request_signature)
         @socket = Net::HTTP.socket_type.new
-        webmock_response = WebMock.response_for_request(request_profile)
+        webmock_response = WebMock.response_for_request(request_signature)
         build_net_http_response(webmock_response, &block)
       elsif WebMock.net_connect_allowed?
-        WebMock::RequestRegistry.instance.requested.put(request_profile)
         connect_without_webmock
         request_without_webmock(request, body, &block)
       else
-        uri = WebMock::Utility.strip_default_port_from_uri(uri)
-        message = "Real HTTP connections are disabled. Unregistered request: #{request.method} #{uri}"
-        message << " with body '#{body}'" if body
-        message << " with headers #{WebMock::Utility.normalize_headers(headers).inspect.gsub("\"","'")}" if 
-headers && !headers.empty?
+        message = "Real HTTP connections are disabled. Unregistered request: #{request_signature}"
         raise WebMock::NetConnectNotAllowedError, message
       end
     end
@@ -101,7 +97,7 @@ headers && !headers.empty?
 
     def connect_with_webmock
       unless @@alredy_checked_for_net_http_replacement_libs ||= false
-        WebMock::Utility.puts_warning_for_net_http_replacement_libs_if_needed
+        WebMock::NetHTTPUtility.puts_warning_for_net_http_replacement_libs_if_needed
         @@alredy_checked_for_net_http_replacement_libs = true
       end
       nil
@@ -127,3 +123,43 @@ headers && !headers.empty?
   end
 
 end
+
+module WebMock
+  module NetHTTPUtility
+    def self.puts_warning_for_net_http_around_advice_libs_if_needed
+      libs = {"Samuel" => defined?(Samuel)}
+      warnings = libs.select { |_, loaded| loaded }.map do |name, _|
+        <<-TEXT.gsub(/ {10}/, '')
+        \e[1mWarning: WebMock was loaded after #{name}\e[0m
+          * #{name}'s code is being ignored when a request is handled by WebMock,
+          because both libraries work by patching Net::HTTP.
+          * To fix this, just reorder your requires so that WebMock is before #{name}.
+          TEXT
+        end
+        $stderr.puts "\n" + warnings.join("\n") + "\n" if warnings.any?
+      end
+
+      def self.record_loaded_net_http_replacement_libs
+        libs = {"RightHttpConnection" => defined?(RightHttpConnection)}
+        @loaded_net_http_replacement_libs = libs.map { |name, loaded| name if loaded }.compact
+      end
+
+      def self.puts_warning_for_net_http_replacement_libs_if_needed
+        libs = {"RightHttpConnection" => defined?(RightHttpConnection)}
+        warnings = libs.select { |_, loaded| loaded }.
+          reject { |name, _| @loaded_net_http_replacement_libs.include?(name) }.
+          map do |name, _|
+          <<-TEXT.gsub(/ {10}/, '')
+          \e[1mWarning: #{name} was loaded after WebMock\e[0m
+            * WebMock's code is being ignored, because #{name} replaces parts of
+            Net::HTTP without deferring to other libraries. This will break Net::HTTP requests.
+            * To fix this, just reorder your requires so that #{name} is before WebMock.
+            TEXT
+          end
+          $stderr.puts "\n" + warnings.join("\n") + "\n" if warnings.any?
+        end
+      end
+    end
+
+    WebMock::NetHTTPUtility.record_loaded_net_http_replacement_libs
+    WebMock::NetHTTPUtility.puts_warning_for_net_http_around_advice_libs_if_needed

data/lib/webmock/request_profile.rb

@@ -4,64 +4,25 @@ module WebMock
 
     def initialize(method, uri, body = nil, headers = nil)
       super
-      self.uri = WebMock::URL.normalize_uri(self.uri) unless self.uri.is_a?(URI)
-      self.headers = Utility.normalize_headers(self.headers)
+      self.uri = WebMock::Util::URI.normalize_uri(self.uri) unless self.uri.is_a?(Addressable::URI)
+      self.headers = WebMock::Util::Headers.normalize_headers(self.headers)
     end
 
     def with(options)
       self.body = options[:body] if options.has_key?(:body)
-      self.headers = Utility.normalize_headers(options[:headers]) if options.has_key?(:headers)
+      self.headers = WebMock::Util::Headers.normalize_headers(options[:headers]) if options.has_key?(:headers)
       self
     end
 
-    #self needs to be a subset of other. Other needs to be more general.
-    def match(other)
-      match_method(other) &&
-      match_body(other) &&
-      match_headers(other) &&
-      match_url(other)
-    end
-
     def to_s
-      string = "#{self.method.to_s.upcase} #{self.uri}"
+      string = "#{self.method.to_s.upcase} #{WebMock::Util::URI.strip_default_port_from_uri_string(self.uri.to_s)}"
       string << " with body '#{body}'" if body
       if headers && !headers.empty?
-        string << " with headers #{WebMock::Utility.normalize_headers(headers).inspect.gsub("\"","'")}"
+        string << " with headers #{WebMock::Util::Headers.normalize_headers(headers).inspect.gsub("\"","'")}"
       end
       string
     end
 
-    private
-
-    def match_url(other)
-      raise "Can't match regexp request profile" if self.uri.is_a?(Regexp)
-      @uris_to_check ||= WebMock::URL.variations_of_uri_as_strings(self.uri)
-      if other.uri.is_a?(URI)
-        @uris_to_check.include?(other.uri.to_s)
-      elsif other.uri.is_a?(Regexp)
-        @uris_to_check.any? { |u| u.match(other.uri) }
-      else
-        false
-      end
-    end
-
-    def match_headers(other)
-      return false if self.headers && !self.headers.empty? && other.headers && other.headers.empty?
-      if other.headers && !other.headers.empty?
-        other.headers.each do | key, value |
-          return false unless (self.headers && self.headers.has_key?(key) && value == self.headers[key])
-        end
-      end
-      return true
-    end
-
-    def match_body(other)
-      other.body == self.body || other.body.nil?
-    end
-
-    def match_method(other)
-      other.method == self.method || other.method == :any
-    end
   end
 
 end

data/lib/webmock/request_registry.rb

@@ -3,7 +3,7 @@ module WebMock
   class RequestRegistry
     include Singleton
 
-    attr_accessor :request_stubs, :requested
+    attr_accessor :request_stubs, :requested_signatures
 
     def initialize
       reset_webmock
@@ -11,7 +11,7 @@ module WebMock
 
     def reset_webmock
       self.request_stubs = []
-      self.requested = HashCounter.new
+      self.requested_signatures = Util::HashCounter.new
     end
 
     def register_request_stub(stub)
@@ -19,27 +19,26 @@ module WebMock
       stub
     end
 
-    def registered_request?(request_profile)
-      stub_for(request_profile)
+    def registered_request?(request_signature)
+      request_stub_for(request_signature)
     end
 
-    def response_for_request(request_profile)
-      stub = stub_for(request_profile)
-      self.requested.put(request_profile)
+    def response_for_request(request_signature)
+      stub = request_stub_for(request_signature)
       stub ? stub.response : nil
     end
     
     def times_executed(request_profile)
-      self.requested.hash.select { |executed_request_profile, times_executed|
-        executed_request_profile.match(request_profile)
+      self.requested_signatures.hash.select { |request_signature, times_executed|
+        request_signature.match(request_profile)
       }.inject(0) {|sum, (_, times_executed)| sum + times_executed }
     end
 
     private
 
-    def stub_for(request_profile)
+    def request_stub_for(request_signature)
       request_stubs.detect { |registered_request_stub|
-        request_profile.match(registered_request_stub.request_profile)
+        request_signature.match(registered_request_stub.request_profile)
       }
     end
 

data/lib/webmock/request_signature.rb

@@ -0,0 +1,44 @@
+module WebMock
+
+  class RequestSignature < RequestProfile
+
+    def match(request_profile)
+      match_method(request_profile) &&
+        match_body(request_profile) &&
+        match_headers(request_profile) &&
+        match_uri(request_profile)
+    end
+
+    private
+
+    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
+    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
+      end
+      return true
+    end
+
+    def match_body(request_profile)
+      request_profile.body == self.body || request_profile.body.nil?
+    end
+
+    def match_method(request_profile)
+      request_profile.method == self.method || request_profile.method == :any
+    end
+  end
+
+
+end

data/lib/webmock/request_stub.rb

@@ -2,15 +2,15 @@ module WebMock
   class RequestStub
     attr_accessor :request_profile, :response
     
-    def initialize(method, url)
-      @request_profile = RequestProfile.new(method, url)
+    def initialize(method, uri)
+      @request_profile = RequestProfile.new(method, uri)
       @response = WebMock::Response.new
       self
     end
 
     def with(params)
       @request_profile.body = params[:body]
-      @request_profile.headers = Utility.normalize_headers(params[:headers])
+      @request_profile.headers = Util::Headers.normalize_headers(params[:headers])
       self
     end
 

data/lib/webmock/response.rb

@@ -6,7 +6,7 @@ module WebMock
     end
 
     def headers
-      Utility.normalize_headers(@options[:headers])
+      Util::Headers.normalize_headers(@options[:headers])
     end
 
     def body

data/lib/webmock/rspec.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), "adapters/rspec")

data/lib/webmock/test_unit.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), "adapters/test_unit")

data/lib/webmock/util/hash_counter.rb

@@ -1,12 +1,20 @@
-class HashCounter
-    attr_accessor :hash
-    def initialize
+module WebMock
+
+  module Util
+
+    class Util::HashCounter
+      attr_accessor :hash
+      def initialize
         self.hash = {}
-    end
-    def put key, num=1
+      end
+      def put key, num=1
         hash[key] = (hash[key] || 0) + num
-    end
-    def get key
+      end
+      def get key
         hash[key] || 0
+      end
     end
-end
+
+  end
+  
+end

data/lib/webmock/util/headers.rb

@@ -0,0 +1,23 @@
+module WebMock
+
+  module Util
+
+    class Headers
+
+      def self.normalize_headers(headers)
+        return nil unless headers
+        array = headers.map { |name, value|
+          [name.to_s.split(/_|-/).map { |segment| segment.capitalize }.join("-"), value.to_s]
+        }
+        Hash[*array.flatten]
+      end
+
+      def self.decode_userinfo_from_header(header)
+        header.sub(/^Basic /, "").unpack("m").first
+      end
+
+    end
+
+  end
+
+end

data/lib/webmock/util/uri.rb

@@ -0,0 +1,81 @@
+module Addressable
+  class URI
+    module CharacterClasses
+      USERINFO = UNRESERVED + SUB_DELIMS + "\\:"
+    end
+  end
+end
+
+module WebMock
+
+  module Util
+
+    class URI
+
+      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 = normalized_uri.query_values if normalized_uri.query_values
+        normalized_uri.normalize!
+        normalized_uri.port = normalized_uri.inferred_port unless normalized_uri.port && normalized_uri.inferred_port
+        normalized_uri
+      end
+
+      def self.variations_of_uri_as_strings(uri_object)
+        normalized_uri = normalize_uri(uri_object.dup).freeze
+        uris = [ normalized_uri ]
+
+        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
+
+        if normalized_uri.path == '/' && normalized_uri.query == nil
+          uris = uris_with_trailing_slash_and_without(uris)
+        end
+
+        uris = uris_encoded_and_unencoded(uris)
+
+        uris.map {|uri| uri.to_s.gsub(/^\/\//,'') }.uniq
+      end
+
+      def self.strip_default_port_from_uri_string(uri_string)
+        case uri_string
+        when %r{^http://}  then uri_string.sub(%r{:80(/|$)}, '\1')
+        when %r{^https://} then uri_string.sub(%r{:443(/|$)}, '\1')
+        else uri_string
+        end
+      end
+
+      def self.encode_unsafe_chars_in_userinfo(userinfo)
+        Addressable::URI.encode_component(userinfo, Addressable::URI::CharacterClasses::USERINFO)
+      end
+
+      private
+
+      def self.uris_with_inferred_port_and_without(uris)
+        uris.map { |uri| [ uri, uri.omit(:port).freeze ] }.flatten
+      end
+
+      def self.uris_encoded_and_unencoded(uris)
+        uris.map do |uri|
+          [ uri, Addressable::URI.heuristic_parse(Addressable::URI.unencode(uri)).freeze ]
+        end.flatten
+      end
+
+      def self.uris_with_scheme_and_without(uris)
+        uris.map { |uri| [ uri, uri.omit(:scheme).freeze ] }.flatten
+      end
+
+      def self.uris_with_trailing_slash_and_without(uris)
+        uris = uris.map { |uri| [ uri, uri.omit(:path).freeze ] }.flatten
+      end
+
+    end
+  end
+
+end