webmock 3.6.2 → 3.14.0

data/lib/webmock/http_lib_adapters/async_http_client_adapter.rb

@@ -0,0 +1,216 @@
+begin
+  require 'async'
+  require 'async/http'
+rescue LoadError
+  # async-http not found
+end
+
+if defined?(Async::HTTP)
+  module WebMock
+    module HttpLibAdapters
+      class AsyncHttpClientAdapter < HttpLibAdapter
+        adapter_for :async_http_client
+
+        OriginalAsyncHttpClient = Async::HTTP::Client unless const_defined?(:OriginalAsyncHttpClient)
+
+        class << self
+          def enable!
+            Async::HTTP.send(:remove_const, :Client)
+            Async::HTTP.send(:const_set, :Client, Async::HTTP::WebMockClientWrapper)
+          end
+
+          def disable!
+            Async::HTTP.send(:remove_const, :Client)
+            Async::HTTP.send(:const_set, :Client, OriginalAsyncHttpClient)
+          end
+        end
+      end
+    end
+  end
+
+  module Async
+    module HTTP
+      class WebMockClientWrapper < Client
+        def initialize(
+          endpoint,
+          protocol = endpoint.protocol,
+          scheme = endpoint.scheme,
+          authority = endpoint.authority,
+          **options
+        )
+          webmock_endpoint = WebMockEndpoint.new(scheme, authority, protocol)
+
+          @network_client = WebMockClient.new(endpoint, **options)
+          @webmock_client = WebMockClient.new(webmock_endpoint, **options)
+
+          @scheme = scheme
+          @authority = authority
+        end
+
+        def call(request)
+          request.scheme ||= self.scheme
+          request.authority ||= self.authority
+
+          request_signature = build_request_signature(request)
+          WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+          webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
+          net_connect_allowed = WebMock.net_connect_allowed?(request_signature.uri)
+          real_request = false
+
+          if webmock_response
+            webmock_response.raise_error_if_any
+            raise Async::TimeoutError, 'WebMock timeout error' if webmock_response.should_timeout
+            WebMockApplication.add_webmock_response(request, webmock_response)
+            response = @webmock_client.call(request)
+          elsif net_connect_allowed
+            response = @network_client.call(request)
+            real_request = true
+          else
+            raise WebMock::NetConnectNotAllowedError.new(request_signature) unless webmock_response
+          end
+
+          if WebMock::CallbackRegistry.any_callbacks?
+            webmock_response ||= build_webmock_response(response)
+            WebMock::CallbackRegistry.invoke_callbacks(
+              {
+                lib: :async_http_client,
+                real_request: real_request
+              },
+              request_signature,
+              webmock_response
+            )
+          end
+
+          response
+        end
+
+        def close
+          @network_client.close
+          @webmock_client.close
+        end
+
+        private
+
+        def build_request_signature(request)
+          body = request.read
+          request.body = ::Protocol::HTTP::Body::Buffered.wrap(body)
+          WebMock::RequestSignature.new(
+            request.method.downcase.to_sym,
+            "#{request.scheme}://#{request.authority}#{request.path}",
+            headers: request.headers.to_h,
+            body: body
+          )
+        end
+
+        def build_webmock_response(response)
+          body = response.read
+          response.body = ::Protocol::HTTP::Body::Buffered.wrap(body)
+
+          webmock_response = WebMock::Response.new
+          webmock_response.status = [
+            response.status,
+            ::Protocol::HTTP1::Reason::DESCRIPTIONS[response.status]
+          ]
+          webmock_response.headers = build_webmock_response_headers(response)
+          webmock_response.body = body
+          webmock_response
+        end
+
+        def build_webmock_response_headers(response)
+          response.headers.each.each_with_object({}) do |(k, v), o|
+            o[k] ||= []
+            o[k] << v
+          end
+        end
+      end
+
+      class WebMockClient < Client
+      end
+
+      class WebMockEndpoint
+        def initialize(scheme, authority, protocol)
+          @scheme = scheme
+          @authority = authority
+          @protocol = protocol
+        end
+
+        attr :scheme, :authority, :protocol
+
+        def connect
+          server_socket, client_socket = create_connected_sockets
+          Async(transient: true) do
+            accept_socket(server_socket)
+          end
+          client_socket
+        end
+
+        def inspect
+          "\#<#{self.class}> #{scheme}://#{authority} protocol=#{protocol}"
+        end
+
+        private
+
+        def create_connected_sockets
+          Async::IO::Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM).tap do |sockets|
+            sockets.each do |socket|
+              socket.instance_variable_set :@alpn_protocol, nil
+              socket.instance_eval do
+                def alpn_protocol
+                  nil # means HTTP11 will be used for HTTPS
+                end
+              end
+            end
+          end
+        end
+
+        def accept_socket(socket)
+          server = Async::HTTP::Server.new(WebMockApplication, self)
+          server.accept(socket, socket.remote_address)
+        end
+      end
+
+      module WebMockApplication
+        WEBMOCK_REQUEST_ID_HEADER = 'x-webmock-request-id'.freeze
+
+        class << self
+          def call(request)
+            request.read
+            webmock_response = get_webmock_response(request)
+            build_response(webmock_response)
+          end
+
+          def add_webmock_response(request, webmock_response)
+            webmock_request_id = request.object_id.to_s
+            request.headers.add(WEBMOCK_REQUEST_ID_HEADER, webmock_request_id)
+            webmock_responses[webmock_request_id] = webmock_response
+          end
+
+          def get_webmock_response(request)
+            webmock_request_id = request.headers[WEBMOCK_REQUEST_ID_HEADER][0]
+            webmock_responses.fetch(webmock_request_id)
+          end
+
+          private
+
+          def webmock_responses
+            @webmock_responses ||= {}
+          end
+
+          def build_response(webmock_response)
+            headers = (webmock_response.headers || {}).each_with_object([]) do |(k, value), o|
+              Array(value).each do |v|
+                o.push [k, v]
+              end
+            end
+
+            ::Protocol::HTTP::Response[
+              webmock_response.status[0],
+              headers,
+              webmock_response.body
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/webmock/http_lib_adapters/curb_adapter.rb

@@ -340,6 +340,10 @@ if defined?(Curl)
 
       def reset
         instance_variable_set(:@body_str, nil)
+        instance_variable_set(:@content_type, nil)
+        instance_variable_set(:@header_str, nil)
+        instance_variable_set(:@last_effective_url, nil)
+        instance_variable_set(:@response_code, nil)
         super
       end
     end

data/lib/webmock/http_lib_adapters/em_http_request_adapter.rb

@@ -99,6 +99,11 @@ if defined?(EventMachine::HttpClient)
         end
       end
 
+      def connection_completed
+        @state = :response_header
+        send_request(request_signature.headers, request_signature.body)
+      end
+
       def send_request(head, body)
         WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
 
@@ -107,7 +112,7 @@ if defined?(EventMachine::HttpClient)
           @uri ||= nil
           EM.next_tick {
             setup(make_raw_response(stubbed_webmock_response), @uri,
-                  stubbed_webmock_response.should_timeout ? "WebMock timeout error" : nil)
+                  stubbed_webmock_response.should_timeout ? Errno::ETIMEDOUT : nil)
           }
           self
         elsif WebMock.net_connect_allowed?(request_signature.uri)
@@ -164,7 +169,7 @@ if defined?(EventMachine::HttpClient)
       end
 
       def build_request_signature
-        headers, body = @req.headers, @req.body
+        headers, body = build_request, @req.body
 
         @conn.middleware.select {|m| m.respond_to?(:request) }.each do |m|
           headers, body = m.request(self, headers, body)
@@ -178,8 +183,6 @@ if defined?(EventMachine::HttpClient)
 
         body = form_encode_body(body) if body.is_a?(Hash)
 
-        headers = @req.headers
-
         if headers['authorization'] && headers['authorization'].is_a?(Array)
           headers['Authorization'] = WebMock::Util::Headers.basic_auth_header(headers.delete('authorization'))
         end

data/lib/webmock/http_lib_adapters/excon_adapter.rb

@@ -159,4 +159,7 @@ if defined?(Excon)
       end
     end
   end
+
+  # Suppresses Excon connection argument validation warning
+  Excon::VALID_CONNECTION_KEYS << :__construction_args
 end

data/lib/webmock/http_lib_adapters/http_rb/client.rb

@@ -4,7 +4,10 @@ module HTTP
 
     def perform(request, options)
       return __perform__(request, options) unless webmock_enabled?
-      WebMockPerform.new(request) { __perform__(request, options) }.exec
+
+      response = WebMockPerform.new(request) { __perform__(request, options) }.exec
+      options.features.each { |_name, feature| response = feature.wrap_response(response) }
+      response
     end
 
     def webmock_enabled?

data/lib/webmock/http_lib_adapters/http_rb/response.rb

@@ -11,20 +11,41 @@ module HTTP
     end
 
     class << self
-      def from_webmock(webmock_response, request_signature = nil)
+      def from_webmock(request, webmock_response, request_signature = nil)
         status  = Status.new(webmock_response.status.first)
         headers = webmock_response.headers || {}
-        body    = Body.new Streamer.new webmock_response.body
         uri     = normalize_uri(request_signature && request_signature.uri)
 
+        # HTTP.rb 3.0+ uses a keyword argument to pass the encoding, but 1.x
+        # and 2.x use a positional argument, and 0.x don't support supplying
+        # the encoding.
+        body = if HTTP::VERSION < "1.0.0"
+          Body.new(Streamer.new(webmock_response.body))
+        elsif HTTP::VERSION < "3.0.0"
+          Body.new(Streamer.new(webmock_response.body), webmock_response.body.encoding)
+        else
+          Body.new(Streamer.new(webmock_response.body), encoding: webmock_response.body.encoding)
+        end
+
         return new(status, "1.1", headers, body, uri) if HTTP::VERSION < "1.0.0"
 
+        # 5.0.0 had a breaking change to require request instead of uri.
+        if HTTP::VERSION < '5.0.0'
+          return new({
+            status: status,
+            version: "1.1",
+            headers: headers,
+            body: body,
+            uri: uri
+          })
+        end
+
         new({
           status: status,
           version: "1.1",
           headers: headers,
           body: body,
-          uri: uri
+          request: request,
         })
       end
 

data/lib/webmock/http_lib_adapters/http_rb/streamer.rb

@@ -5,7 +5,7 @@ module HTTP
         @io = StringIO.new str
       end
 
-      def readpartial(size = nil)
+      def readpartial(size = nil, outbuf = nil)
         unless size
           if defined?(HTTP::Client::BUFFER_SIZE)
             size = HTTP::Client::BUFFER_SIZE
@@ -14,7 +14,7 @@ module HTTP
           end
         end
 
-        @io.read size
+        @io.read size, outbuf
       end
 
       def close

data/lib/webmock/http_lib_adapters/http_rb/webmock.rb

@@ -38,7 +38,7 @@ module HTTP
       webmock_response.raise_error_if_any
 
       invoke_callbacks(webmock_response, real_request: false)
-      ::HTTP::Response.from_webmock webmock_response, request_signature
+      ::HTTP::Response.from_webmock @request, webmock_response, request_signature
     end
 
     def raise_timeout_error

data/lib/webmock/http_lib_adapters/httpclient_adapter.rb

@@ -43,6 +43,9 @@ if defined?(::HTTPClient)
   end
 
   module WebMockHTTPClients
+
+    REQUEST_RESPONSE_LOCK = Mutex.new
+
     def do_get_block(req, proxy, conn, &block)
       do_get(req, proxy, conn, false, &block)
     end
@@ -57,7 +60,7 @@ if defined?(::HTTPClient)
       WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
 
       if webmock_responses[request_signature]
-        webmock_response = webmock_responses.delete(request_signature)
+        webmock_response = synchronize_request_response { webmock_responses.delete(request_signature) }
         response = build_httpclient_response(webmock_response, stream, req.header, &block)
         @request_filter.each do |filter|
           filter.filter_response(req, response)
@@ -68,7 +71,7 @@ if defined?(::HTTPClient)
         res
       elsif WebMock.net_connect_allowed?(request_signature.uri)
         # in case there is a nil entry in the hash...
-        webmock_responses.delete(request_signature)
+        synchronize_request_response { webmock_responses.delete(request_signature) }
 
         res = if stream
           do_get_stream_without_webmock(req, proxy, conn, &block)
@@ -100,7 +103,7 @@ if defined?(::HTTPClient)
     def do_request_async(method, uri, query, body, extheader)
       req = create_request(method, uri, query, body, extheader)
       request_signature = build_request_signature(req)
-      webmock_request_signatures << request_signature
+      synchronize_request_response { webmock_request_signatures << request_signature }
 
       if webmock_responses[request_signature] || WebMock.net_connect_allowed?(request_signature.uri)
         super
@@ -184,7 +187,9 @@ if defined?(::HTTPClient)
 
     def webmock_responses
       @webmock_responses ||= Hash.new do |hash, request_signature|
-        hash[request_signature] = WebMock::StubRegistry.instance.response_for_request(request_signature)
+        synchronize_request_response do
+          hash[request_signature] = WebMock::StubRegistry.instance.response_for_request(request_signature)
+        end
       end
     end
 
@@ -193,8 +198,10 @@ if defined?(::HTTPClient)
     end
 
     def previous_signature_for(signature)
-      return nil unless index = webmock_request_signatures.index(signature)
-      webmock_request_signatures.delete_at(index)
+      synchronize_request_response do
+        return nil unless index = webmock_request_signatures.index(signature)
+        webmock_request_signatures.delete_at(index)
+      end
     end
 
     private
@@ -209,6 +216,16 @@ if defined?(::HTTPClient)
         hdrs
       end
     end
+
+    def synchronize_request_response
+      if REQUEST_RESPONSE_LOCK.owned?
+        yield
+      else
+        REQUEST_RESPONSE_LOCK.synchronize do
+          yield
+        end
+      end
+    end
   end
 
   class WebMockHTTPClient < HTTPClient

data/lib/webmock/http_lib_adapters/manticore_adapter.rb

@@ -24,6 +24,12 @@ if defined?(Manticore)
           Manticore.instance_variable_set(:@manticore_facade, OriginalManticoreClient.new)
         end
 
+        class StubbedTimeoutResponse < Manticore::StubbedResponse
+          def call
+            @handlers[:failure].call(Manticore::ConnectTimeout.new("Too slow (mocked timeout)"))
+          end
+        end
+
         class WebMockManticoreClient < Manticore::Client
           def request(klass, url, options={}, &block)
             super(klass, WebMock::Util::URI.normalize_uri(url).to_s, format_options(options))
@@ -106,21 +112,30 @@ if defined?(Manticore)
           end
 
           def generate_manticore_response(webmock_response)
-            raise Manticore::ConnectTimeout if webmock_response.should_timeout
-
-            Manticore::StubbedResponse.stub(
-              code: webmock_response.status[0],
-              body: webmock_response.body,
-              headers: webmock_response.headers,
-              cookies: {}
-            )
+            if webmock_response.should_timeout
+              StubbedTimeoutResponse.new
+            else
+              Manticore::StubbedResponse.stub(
+                code: webmock_response.status[0],
+                body: webmock_response.body,
+                headers: webmock_response.headers,
+                cookies: {}
+              )
+            end
           end
 
           def generate_webmock_response(manticore_response)
             webmock_response = WebMock::Response.new
             webmock_response.status = [manticore_response.code, manticore_response.message]
-            webmock_response.body = manticore_response.body
             webmock_response.headers = manticore_response.headers
+
+            # The attempt to read the body could fail if manticore is used in a streaming mode
+            webmock_response.body = begin
+              manticore_response.body
+            rescue ::Manticore::StreamClosedException
+              nil
+            end
+
             webmock_response
           end
         end

data/lib/webmock/http_lib_adapters/net_http.rb

@@ -228,9 +228,9 @@ class PatchedStringIO < StringIO #:nodoc:
 
   alias_method :orig_read_nonblock, :read_nonblock
 
-  def read_nonblock(size, *args)
+  def read_nonblock(size, *args, **kwargs)
     args.reject! {|arg| !arg.is_a?(Hash)}
-    orig_read_nonblock(size, *args)
+    orig_read_nonblock(size, *args, **kwargs)
   end
 
 end
@@ -252,12 +252,19 @@ class StubSocket #:nodoc:
   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(io, *args)
+    def initialize(io, *args, **kwargs)
       io = case io
       when Socket, OpenSSL::SSL::SSLSocket, IO
         io
@@ -268,23 +275,33 @@ module Net  #:nodoc: all
       end
       raise "Unable to create local socket" unless io
 
-      super
+      # 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
-        current_thread_id = Thread.current.object_id
-
-        trace = TracePoint.trace(:line) do |tp|
-          next unless Thread.current.object_id == current_thread_id
-          if tp.binding.local_variable_defined?(:tmp)
-            tp.binding.local_variable_set(:tmp, nil)
-          end
-        end
-
-        super
-      ensure
-        trace.disable
+        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
     end
   end
@@ -296,8 +313,6 @@ 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
 
       if path.respond_to?(:request_uri) #https://github.com/bblimke/webmock/issues/288
@@ -306,7 +321,7 @@ module WebMock
 
       path = WebMock::Util::URI.heuristic_parse(path).request_uri if path =~ /^http/
 
-      uri = "#{protocol}://#{net_http.address}:#{net_http.port}#{path}"
+      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}]
@@ -326,6 +341,15 @@ module WebMock
       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