webmock 3.5.1 → 3.11.2

data/Rakefile

@@ -1,5 +1,3 @@
-#!/usr/bin/env rake
-
 require 'bundler'
 Bundler::GemHelper.install_tasks
 

data/lib/webmock.rb

@@ -54,5 +54,6 @@ require_relative 'webmock/http_lib_adapters/em_http_request_adapter'
 require_relative 'webmock/http_lib_adapters/typhoeus_hydra_adapter'
 require_relative 'webmock/http_lib_adapters/excon_adapter'
 require_relative 'webmock/http_lib_adapters/manticore_adapter'
+require_relative 'webmock/http_lib_adapters/async_http_client_adapter'
 
 require_relative 'webmock/webmock'

data/lib/webmock/http_lib_adapters/async_http_client_adapter.rb

@@ -0,0 +1,214 @@
+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)
+
+          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)
+          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: net_connect_allowed
+              },
+              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

@@ -54,7 +54,6 @@ if defined?(Curl)
 
   module Curl
     class WebMockCurlEasy < Curl::Easy
-
       def curb_or_webmock
         request_signature = build_request_signature
         WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
@@ -271,6 +270,8 @@ if defined?(Curl)
       def perform
         @webmock_method ||= :get
         curb_or_webmock { super }
+      ensure
+        reset_webmock_method
       end
 
       def put_data= data
@@ -333,8 +334,16 @@ if defined?(Curl)
         METHOD
       end
 
+      def reset_webmock_method
+        @webmock_method = :get
+      end
+
       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

@@ -107,7 +107,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)

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

@@ -14,9 +14,19 @@ module HTTP
       def from_webmock(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"
 
         new({

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/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))
@@ -50,19 +56,22 @@ if defined?(Manticore)
 
             if webmock_response = registered_response_for(request_signature)
               webmock_response.raise_error_if_any
-              manticore_response = generate_manticore_response(webmock_response).call
-              real_request = false
+              manticore_response = generate_manticore_response(webmock_response)
+              manticore_response.on_success do
+                WebMock::CallbackRegistry.invoke_callbacks({lib: :manticore, real_request: false}, request_signature, webmock_response)
+              end
 
             elsif real_request_allowed?(request_signature.uri)
-              manticore_response = Manticore::Response.new(self, request, context, &block).call
-              webmock_response = generate_webmock_response(manticore_response)
-              real_request = true
+              manticore_response = Manticore::Response.new(self, request, context, &block)
+              manticore_response.on_complete do |completed_response|
+                webmock_response = generate_webmock_response(completed_response)
+                WebMock::CallbackRegistry.invoke_callbacks({lib: :manticore, real_request: true}, request_signature, webmock_response)
+              end
 
             else
               raise WebMock::NetConnectNotAllowedError.new(request_signature)
             end
 
-            WebMock::CallbackRegistry.invoke_callbacks({lib: :manticore, real_request: real_request}, request_signature, webmock_response)
             manticore_response
           end
 
@@ -103,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