webmock 1.8.6 → 3.14.0

data/lib/webmock/http_lib_adapters/net_http.rb

@@ -28,15 +28,23 @@ module WebMock
         Net.send(:const_set, :HTTP, OriginalNetHTTP)
         Net.send(:const_set, :HTTPSession, OriginalNetHTTP)
         Net.send(:const_set, :BufferedIO, OriginalNetBufferedIO)
+
+        #copy all constants from @webMockNetHTTP to original Net::HTTP
+        #in case any constants were added to @webMockNetHTTP instead of Net::HTTP
+        #after WebMock was enabled.
+        #i.e Net::HTTP::DigestAuth
+        @webMockNetHTTP.constants.each do |constant|
+          if !OriginalNetHTTP.constants.map(&:to_s).include?(constant.to_s)
+            OriginalNetHTTP.send(:const_set, constant, @webMockNetHTTP.const_get(constant))
+          end
+        end
       end
 
       @webMockNetHTTP = Class.new(Net::HTTP) do
         class << self
-          def socket_type_with_webmock
+          def socket_type
             StubSocket
           end
-          alias_method :socket_type_without_webmock, :socket_type
-          alias_method :socket_type, :socket_type_with_webmock
 
           if Module.method(:const_defined?).arity == 1
             def const_defined?(name)
@@ -58,12 +66,12 @@ module WebMock
 
           if Module.method(:constants).arity != 0
             def constants(inherit=true)
-              super + self.superclass.constants(inherit)
+              (super + self.superclass.constants(inherit)).uniq
             end
           end
         end
 
-        def request_with_webmock(request, body = nil, &block)
+        def request(request, body = nil, &block)
           request_signature = WebMock::NetHTTPUtility.request_signature_from_request(self, request, body)
 
           WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
@@ -71,7 +79,7 @@ module WebMock
           if webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
             @socket = Net::HTTP.socket_type.new
             WebMock::CallbackRegistry.invoke_callbacks(
-              {:lib => :net_http}, request_signature, webmock_response)
+              {lib: :net_http}, request_signature, webmock_response)
             build_net_http_response(webmock_response, &block)
           elsif WebMock.net_connect_allowed?(request_signature.uri)
             check_right_http_connection
@@ -79,28 +87,33 @@ module WebMock
               if WebMock::CallbackRegistry.any_callbacks?
                 webmock_response = build_webmock_response(response)
                 WebMock::CallbackRegistry.invoke_callbacks(
-                  {:lib => :net_http, :real_request => true}, request_signature, webmock_response)
+                  {lib: :net_http, real_request: true}, request_signature, webmock_response)
               end
               response.extend Net::WebMockHTTPResponse
               block.call response if block
               response
             end
-            response = if (started? && !WebMock::Config.instance.net_http_connect_on_start) || !started?
-              @started = false #otherwise start_with_connect wouldn't execute and connect
+            super_with_after_request = lambda {
+              response = super(request, nil, &nil)
+              after_request.call(response)
+            }
+            if started?
+              if WebMock::Config.instance.net_http_connect_on_start
+                super_with_after_request.call
+              else
+                start_with_connect_without_finish {
+                  super_with_after_request.call
+                }
+              end
+            else
               start_with_connect {
-                response = request_without_webmock(request, nil)
-                after_request.call(response)
+                super_with_after_request.call
               }
-            else
-              response = request_without_webmock(request, nil)
-              after_request.call(response)
             end
           else
             raise WebMock::NetConnectNotAllowedError.new(request_signature)
           end
         end
-        alias_method :request_without_webmock, :request
-        alias_method :request, :request_with_webmock
 
         def start_without_connect
           raise IOError, 'HTTP session already opened' if @started
@@ -116,19 +129,34 @@ module WebMock
           self
         end
 
-        def start_with_conditional_connect(&block)
+
+        def start_with_connect_without_finish  # :yield: http
+          if block_given?
+            begin
+              do_start
+              return yield(self)
+            end
+          end
+          do_start
+          self
+        end
+
+        alias_method :start_with_connect, :start
+
+        def start(&block)
           if WebMock::Config.instance.net_http_connect_on_start
-            start_with_connect(&block)
+            super(&block)
           else
             start_without_connect(&block)
           end
         end
-        alias_method :start_with_connect, :start
-        alias_method :start, :start_with_conditional_connect
 
         def build_net_http_response(webmock_response, &block)
           response = Net::HTTPResponse.send(:response_class, webmock_response.status[0].to_s).new("1.0", webmock_response.status[0].to_s, webmock_response.status[1])
-          response.instance_variable_set(:@body, webmock_response.body)
+          body = webmock_response.body
+          body = nil if webmock_response.status[0].to_s == '204'
+
+          response.instance_variable_set(:@body, body)
           webmock_response.headers.to_a.each do |name, values|
             values = [values] unless values.is_a?(Array)
             values.each do |value|
@@ -140,7 +168,9 @@ module WebMock
 
           response.extend Net::WebMockHTTPResponse
 
-          raise Timeout::Error, "execution expired" if webmock_response.should_timeout
+          if webmock_response.should_timeout
+            raise timeout_exception, "execution expired"
+          end
 
           webmock_response.raise_error_if_any
 
@@ -149,6 +179,16 @@ module WebMock
           response
         end
 
+        def timeout_exception
+          if defined?(Net::OpenTimeout)
+            # Ruby 2.x
+            Net::OpenTimeout
+          else
+            # Fallback, if things change
+            Timeout::Error
+          end
+        end
+
         def build_webmock_response(net_http_response)
           webmock_response = WebMock::Response.new
           webmock_response.status = [
@@ -182,9 +222,22 @@ module WebMock
   end
 end
 
+# patch for StringIO behavior in Ruby 2.2.3
+# https://github.com/bblimke/webmock/issues/558
+class PatchedStringIO < StringIO #:nodoc:
+
+  alias_method :orig_read_nonblock, :read_nonblock
+
+  def read_nonblock(size, *args, **kwargs)
+    args.reject! {|arg| !arg.is_a?(Hash)}
+    orig_read_nonblock(size, *args, **kwargs)
+  end
+
+end
+
 class StubSocket #:nodoc:
 
-  attr_accessor :read_timeout
+  attr_accessor :read_timeout, :continue_timeout, :write_timeout
 
   def initialize(*args)
   end
@@ -193,29 +246,64 @@ class StubSocket #:nodoc:
     @closed ||= true
   end
 
+  def close
+  end
+
   def readuntil(*args)
   end
 
+  def io
+    @io ||= StubIO.new
+  end
+
+  class StubIO
+    def setsockopt(*args); end
+  end
 end
 
 module Net  #:nodoc: all
 
   class WebMockNetBufferedIO < BufferedIO
-    def initialize_with_webmock(io, debug_output = nil)
-      @read_timeout = 60
-      @rbuf = ''
-      @debug_output = debug_output
-
-      @io = case io
+    def initialize(io, *args, **kwargs)
+      io = case io
       when Socket, OpenSSL::SSL::SSLSocket, IO
         io
+      when StringIO
+        PatchedStringIO.new(io.string)
       when String
-        StringIO.new(io)
+        PatchedStringIO.new(io)
+      end
+      raise "Unable to create local socket" unless io
+
+      # Prior to 2.4.0 `BufferedIO` only takes a single argument (`io`) with no
+      # options. Here we pass through our full set of arguments only if we're
+      # on 2.4.0 or later, and use a simplified invocation otherwise.
+      if RUBY_VERSION >= '2.4.0'
+        super
+      else
+        super(io)
+      end
+    end
+
+    if RUBY_VERSION >= '2.6.0'
+      # https://github.com/ruby/ruby/blob/7d02441f0d6e5c9d0a73a024519eba4f69e36dce/lib/net/protocol.rb#L208
+      # Modified version of method from ruby, so that nil is always passed into orig_read_nonblock to avoid timeout
+      def rbuf_fill
+        case rv = @io.read_nonblock(BUFSIZE, nil, exception: false)
+        when String
+          return if rv.nil?
+          @rbuf << rv
+          rv.clear
+          return
+        when :wait_readable
+          @io.to_io.wait_readable(@read_timeout) or raise Net::ReadTimeout
+        when :wait_writable
+          @io.to_io.wait_writable(@read_timeout) or raise Net::ReadTimeout
+        when nil
+          raise EOFError, 'end of file reached'
+        end while true
       end
-      raise "Unable to create local socket" unless @io
     end
-    alias_method :initialize_without_webmock, :initialize
-    alias_method :initialize, :initialize_with_webmock
   end
 
 end
@@ -225,25 +313,19 @@ module WebMock
   module NetHTTPUtility
 
     def self.request_signature_from_request(net_http, request, body = nil)
-      protocol = net_http.use_ssl? ? "https" : "http"
-
       path = request.path
-      path = WebMock::Util::URI.heuristic_parse(request.path).request_uri if request.path =~ /^http/
 
-      if request["authorization"] =~ /^Basic /
-        userinfo = WebMock::Util::Headers.decode_userinfo_from_header(request["authorization"])
-        userinfo = WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo) + "@"
-      else
-        userinfo = ""
+      if path.respond_to?(:request_uri) #https://github.com/bblimke/webmock/issues/288
+        path = path.request_uri
       end
 
-      uri = "#{protocol}://#{userinfo}#{net_http.address}:#{net_http.port}#{path}"
+      path = WebMock::Util::URI.heuristic_parse(path).request_uri if path =~ /^http/
+
+      uri = get_uri(net_http, path)
       method = request.method.downcase.to_sym
 
       headers = Hash[*request.to_hash.map {|k,v| [k, v]}.inject([]) {|r,x| r + x}]
-
-      headers.reject! {|k,v| k =~ /[Aa]uthorization/ && v.first =~ /^Basic / } #we added it to url userinfo
-
+      validate_headers(headers)
 
       if request.body_stream
         body = request.body_stream.read
@@ -256,9 +338,36 @@ module WebMock
         request.set_body_internal body
       end
 
-      WebMock::RequestSignature.new(method, uri, :body => request.body, :headers => headers)
+      WebMock::RequestSignature.new(method, uri, body: request.body, headers: headers)
+    end
+
+    def self.get_uri(net_http, path)
+      protocol = net_http.use_ssl? ? "https" : "http"
+
+      hostname = net_http.address
+      hostname = "[#{hostname}]" if /\A\[.*\]\z/ !~ hostname && /:/ =~ hostname
+
+      "#{protocol}://#{hostname}:#{net_http.port}#{path}"
     end
 
+    def self.validate_headers(headers)
+      # For Ruby versions < 2.3.0, if you make a request with headers that are symbols
+      # Net::HTTP raises a NoMethodError
+      #
+      # WebMock normalizes headers when creating a RequestSignature,
+      # and will update all headers from symbols to strings.
+      #
+      # This could create a false positive in a test suite with WebMock.
+      #
+      # So before this point, WebMock raises an ArgumentError if any of the headers are symbols
+      # instead of the cryptic NoMethodError "undefined method `split' ...` from Net::HTTP
+      if Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('2.3.0')
+        header_as_symbol = headers.keys.find {|header| header.is_a? Symbol}
+        if header_as_symbol
+          raise ArgumentError.new("Net:HTTP does not accept headers as symbols")
+        end
+      end
+    end
 
     def self.check_right_http_connection
       @was_right_http_connection_loaded = defined?(RightHttpConnection)

data/lib/webmock/http_lib_adapters/net_http_response.rb

@@ -23,7 +23,7 @@ module Net
       return nil if @body.nil?
 
       dest ||= ::Net::ReadAdapter.new(block)
-      dest << @body
+      dest << @body.dup
       @body = dest
     ensure
       # allow subsequent calls to #read_body to proceed as normal, without our hack...

data/lib/webmock/http_lib_adapters/patron_adapter.rb

@@ -13,7 +13,7 @@ if defined?(::Patron)
         OriginalPatronSession = ::Patron::Session unless const_defined?(:OriginalPatronSession)
 
         class WebMockPatronSession < ::Patron::Session
-          def handle_request_with_webmock(req)
+          def handle_request(req)
             request_signature =
               WebMock::HttpLibAdapters::PatronAdapter.build_request_signature(req)
 
@@ -25,15 +25,15 @@ if defined?(::Patron)
               res = WebMock::HttpLibAdapters::PatronAdapter.
                 build_patron_response(webmock_response, default_response_charset)
               WebMock::CallbackRegistry.invoke_callbacks(
-                {:lib => :patron}, request_signature, webmock_response)
+                {lib: :patron}, request_signature, webmock_response)
               res
             elsif WebMock.net_connect_allowed?(request_signature.uri)
-              res = handle_request_without_webmock(req)
+              res = super
               if WebMock::CallbackRegistry.any_callbacks?
                 webmock_response = WebMock::HttpLibAdapters::PatronAdapter.
                   build_webmock_response(res)
                 WebMock::CallbackRegistry.invoke_callbacks(
-                  {:lib => :patron, :real_request => true}, request_signature,
+                  {lib: :patron, real_request: true}, request_signature,
                     webmock_response)
               end
               res
@@ -41,9 +41,6 @@ if defined?(::Patron)
               raise WebMock::NetConnectNotAllowedError.new(request_signature)
             end
           end
-
-          alias_method :handle_request_without_webmock, :handle_request
-          alias_method :handle_request, :handle_request_with_webmock
         end
 
         def self.enable!
@@ -71,10 +68,8 @@ if defined?(::Patron)
         def self.build_request_signature(req)
           uri = WebMock::Util::URI.heuristic_parse(req.url)
           uri.path = uri.normalized_path.gsub("[^:]//","/")
-          uri.user = req.username
-          uri.password = req.password
 
-          if [:put, :post].include?(req.action)
+          if [:put, :post, :patch].include?(req.action)
             if req.file_name
               if !File.exist?(req.file_name) || !File.readable?(req.file_name)
                 raise ArgumentError.new("Unable to open specified file.")
@@ -87,11 +82,17 @@ if defined?(::Patron)
             end
           end
 
+          headers = req.headers
+
+          if req.credentials
+            headers['Authorization'] = WebMock::Util::Headers.basic_auth_header(req.credentials)
+          end
+
           request_signature = WebMock::RequestSignature.new(
             req.action,
             uri.to_s,
-            :body => request_body,
-            :headers => req.headers
+            body: request_body,
+            headers: headers
           )
           request_signature
         end
@@ -105,11 +106,11 @@ if defined?(::Patron)
           header_data   = ([status_line] + header_fields).join("\r\n")
 
           ::Patron::Response.new(
-            "",
+            "".dup,
             webmock_response.status[0],
             0,
             header_data,
-            webmock_response.body,
+            webmock_response.body.dup,
             default_response_charset
           )
         end
@@ -117,7 +118,7 @@ if defined?(::Patron)
         def self.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]+)?))[0][2]
+            scan(%r(\AHTTP/(\d+(?:\.\d+)?)\s+(\d\d\d)\s*([^\r\n]+)?))[0][2]
           webmock_response.status = [patron_response.status, reason]
           webmock_response.body = patron_response.body
           webmock_response.headers = patron_response.headers

data/lib/webmock/http_lib_adapters/typhoeus_hydra_adapter.rb

@@ -14,53 +14,63 @@ if defined?(Typhoeus)
 
         def self.enable!
           @disabled = false
+          add_before_callback
           add_after_request_callback
-          ::Typhoeus::Hydra.allow_net_connect = true
+          ::Typhoeus::Config.block_connection = true
         end
 
         def self.disable!
           @disabled = true
           remove_after_request_callback
-          ::Typhoeus::Hydra.allow_net_connect = true
+          remove_before_callback
+          ::Typhoeus::Config.block_connection = false
         end
 
         def self.disabled?
           !!@disabled
         end
 
+        def self.add_before_callback
+          unless Typhoeus.before.include?(BEFORE_CALLBACK)
+            Typhoeus.before << BEFORE_CALLBACK
+          end
+        end
+
+        def self.remove_before_callback
+          Typhoeus.before.delete_if {|v| v == BEFORE_CALLBACK }
+        end
+
         def self.add_after_request_callback
-          unless Typhoeus::Hydra.
-            global_hooks[:after_request_before_on_complete].
-              include?(AFTER_REQUEST_CALLBACK)
-            Typhoeus::Hydra.
-              global_hooks[:after_request_before_on_complete] << AFTER_REQUEST_CALLBACK
+          unless Typhoeus.on_complete.include?(AFTER_REQUEST_CALLBACK)
+            Typhoeus.on_complete << AFTER_REQUEST_CALLBACK
           end
         end
 
         def self.remove_after_request_callback
-          Typhoeus::Hydra.global_hooks[:after_request_before_on_complete].
-            delete_if {|v| v == AFTER_REQUEST_CALLBACK }
+          Typhoeus.on_complete.delete_if {|v| v == AFTER_REQUEST_CALLBACK }
         end
 
         def self.build_request_signature(req)
           uri = WebMock::Util::URI.heuristic_parse(req.url)
           uri.path = uri.normalized_path.gsub("[^:]//","/")
-          if req.username
-            uri.user = req.username
-            uri.password = req.password
+
+          headers = req.options[:headers]
+
+          if req.options[:userpwd]
+            headers['Authorization'] = WebMock::Util::Headers.basic_auth_header(req.options[:userpwd])
           end
 
-          body = req.body
+          body = req.options[:body]
 
-          if req.params && req.method == :post
-            body = request_body_for_post_request_with_params(req)
+          if body.is_a?(Hash)
+            body = WebMock::Util::QueryMapper.values_to_query(body)
           end
 
           request_signature = WebMock::RequestSignature.new(
-            req.method,
+            req.options[:method] || :get,
             uri.to_s,
-            :body => body,
-            :headers => req.headers
+            body: body,
+            headers: headers
           )
 
           req.instance_variable_set(:@__webmock_request_signature, request_signature)
@@ -68,45 +78,35 @@ if defined?(Typhoeus)
           request_signature
         end
 
-        def self.request_body_for_post_request_with_params(req)
-          params = req.params
-          form = Typhoeus::Form.new(params)
-          form.process!
-          form.to_s
-        end
 
         def self.build_webmock_response(typhoeus_response)
           webmock_response = WebMock::Response.new
           webmock_response.status = [typhoeus_response.code, typhoeus_response.status_message]
           webmock_response.body = typhoeus_response.body
-          webmock_response.headers = typhoeus_response.headers_hash
+          webmock_response.headers = typhoeus_response.headers
           webmock_response
         end
 
-        def self.stub_typhoeus(request_signature, webmock_response, typhoeus)
+        def self.generate_typhoeus_response(request_signature, webmock_response)
           response = if webmock_response.should_timeout
             ::Typhoeus::Response.new(
-              :code         => 0,
-              :status_message => "",
-              :body         => "",
-              :headers_hash => {},
-              :curl_return_code => 28
+              code: 0,
+              status_message: "",
+              body: "",
+              headers: {},
+              return_code: :operation_timedout
             )
           else
             ::Typhoeus::Response.new(
-              :code         => webmock_response.status[0],
-              :status_message => webmock_response.status[1],
-              :body         => webmock_response.body,
-              :headers_hash => webmock_response.headers
+              code: webmock_response.status[0],
+              status_message: webmock_response.status[1],
+              body: webmock_response.body,
+              headers: webmock_response.headers,
+              effective_url: request_signature.uri
             )
           end
-
-
-          typhoeus.stub(
-            request_signature.method || :any,
-            /.*/,
-            :webmock_stub => true
-          ).and_return(response)
+          response.mock = :webmock
+          response
         end
 
         def self.request_hash(request_signature)
@@ -118,62 +118,56 @@ if defined?(Typhoeus)
           hash
         end
 
-        AFTER_REQUEST_CALLBACK = Proc.new do |request|
+        AFTER_REQUEST_CALLBACK = Proc.new do |response|
+          request = response.request
           request_signature = request.instance_variable_get(:@__webmock_request_signature)
           webmock_response =
             ::WebMock::HttpLibAdapters::TyphoeusAdapter.
-              build_webmock_response(request.response)
-          if request.response.mock?
+              build_webmock_response(response)
+          if response.mock
             WebMock::CallbackRegistry.invoke_callbacks(
-              {:lib => :typhoeus},
+              {lib: :typhoeus},
               request_signature,
               webmock_response
             )
           else
             WebMock::CallbackRegistry.invoke_callbacks(
-              {:lib => :typhoeus, :real_request => true},
+              {lib: :typhoeus, real_request: true},
               request_signature,
               webmock_response
             )
           end
         end
-      end
-    end
-  end
-
-
-  module Typhoeus
-    class Hydra
-      def queue_with_webmock(request)
-        self.clear_webmock_stubs
-
-        if WebMock::HttpLibAdapters::TyphoeusAdapter.disabled?
-          return queue_without_webmock(request)
-        end
-
-        request_signature =
-         ::WebMock::HttpLibAdapters::TyphoeusAdapter.build_request_signature(request)
 
-        ::WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
-
-        if webmock_response = ::WebMock::StubRegistry.instance.response_for_request(request_signature)
-          ::WebMock::HttpLibAdapters::TyphoeusAdapter.
-            stub_typhoeus(request_signature, webmock_response, self)
-          webmock_response.raise_error_if_any
-        elsif !WebMock.net_connect_allowed?(request_signature.uri)
-          raise WebMock::NetConnectNotAllowedError.new(request_signature)
+        BEFORE_CALLBACK = Proc.new do |request|
+          Typhoeus::Expectation.all.delete_if {|e| e.from == :webmock }
+          res = true
+
+          unless WebMock::HttpLibAdapters::TyphoeusAdapter.disabled?
+            request_signature = ::WebMock::HttpLibAdapters::TyphoeusAdapter.build_request_signature(request)
+            request.block_connection = false;
+
+            ::WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+            if webmock_response = ::WebMock::StubRegistry.instance.response_for_request(request_signature)
+              # ::WebMock::HttpLibAdapters::TyphoeusAdapter.stub_typhoeus(request_signature, webmock_response, self)
+              response = ::WebMock::HttpLibAdapters::TyphoeusAdapter.generate_typhoeus_response(request_signature, webmock_response)
+              if request.respond_to?(:on_headers)
+                request.execute_headers_callbacks(response)
+              end
+              if request.respond_to?(:streaming?) && request.streaming?
+                response.options[:response_body] = ""
+                request.on_body.each { |callback| callback.call(webmock_response.body, response) }
+              end
+              request.finish(response)
+              webmock_response.raise_error_if_any
+              res = false
+            elsif !WebMock.net_connect_allowed?(request_signature.uri)
+              raise WebMock::NetConnectNotAllowedError.new(request_signature)
+            end
+          end
+          res
         end
-        queue_without_webmock(request)
-      end
-
-      alias_method :queue_without_webmock, :queue
-      alias_method :queue, :queue_with_webmock
-
-      def clear_webmock_stubs
-        self.stubs = [] unless self.stubs
-        self.stubs.delete_if {|s|
-          s.instance_variable_get(:@options)[:webmock_stub]
-        }
       end
     end
   end

data/lib/webmock/matchers/any_arg_matcher.rb

@@ -0,0 +1,13 @@
+module WebMock
+  module Matchers
+    # this is a based on RSpec::Mocks::ArgumentMatchers::AnyArgMatcher
+    class AnyArgMatcher
+      def initialize(ignore)
+      end
+
+      def ==(other)
+        true
+      end
+    end
+  end
+end