webmock 1.8.6 → 3.14.0

data/lib/webmock/http_lib_adapters/httpclient_adapter.rb

@@ -1,7 +1,9 @@
 begin
   require 'httpclient'
+  require 'jsonclient' # defined in 'httpclient' gem as well
 rescue LoadError
   # httpclient not found
+  # or jsonclient not defined (in old versions of httclient gem)
 end
 
 if defined?(::HTTPClient)
@@ -11,59 +13,85 @@ if defined?(::HTTPClient)
       class HTTPClientAdapter < HttpLibAdapter
         adapter_for :httpclient
 
-        OriginalHttpClient = ::HTTPClient unless const_defined?(:OriginalHttpClient)
+        unless const_defined?(:OriginalHttpClient)
+          OriginalHttpClient = ::HTTPClient
+        end
+
+        unless const_defined?(:OriginalJsonClient)
+          OriginalJsonClient = ::JSONClient if defined?(::JSONClient)
+        end
 
         def self.enable!
           Object.send(:remove_const, :HTTPClient)
           Object.send(:const_set, :HTTPClient, WebMockHTTPClient)
+          if defined? ::JSONClient
+            Object.send(:remove_const, :JSONClient)
+            Object.send(:const_set, :JSONClient, WebMockJSONClient)
+          end
         end
 
         def self.disable!
           Object.send(:remove_const, :HTTPClient)
           Object.send(:const_set, :HTTPClient, OriginalHttpClient)
+          if defined? ::JSONClient
+            Object.send(:remove_const, :JSONClient)
+            Object.send(:const_set, :JSONClient, OriginalJsonClient)
+          end
         end
       end
     end
   end
 
+  module WebMockHTTPClients
 
-  class WebMockHTTPClient < HTTPClient
+    REQUEST_RESPONSE_LOCK = Mutex.new
 
-    def do_get_block_with_webmock(req, proxy, conn, &block)
-      do_get_with_webmock(req, proxy, conn, false, &block)
+    def do_get_block(req, proxy, conn, &block)
+      do_get(req, proxy, conn, false, &block)
     end
 
-    def do_get_stream_with_webmock(req, proxy, conn, &block)
-      do_get_with_webmock(req, proxy, conn, true, &block)
+    def do_get_stream(req, proxy, conn, &block)
+      do_get(req, proxy, conn, true, &block)
     end
 
-    def do_get_with_webmock(req, proxy, conn, stream = false, &block)
+    def do_get(req, proxy, conn, stream = false, &block)
       request_signature = build_request_signature(req, :reuse_existing)
 
       WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
 
       if webmock_responses[request_signature]
-        webmock_response = webmock_responses.delete(request_signature)
-        response = build_httpclient_response(webmock_response, stream, &block)
+        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)
         end
         res = conn.push(response)
         WebMock::CallbackRegistry.invoke_callbacks(
-          {:lib => :httpclient}, request_signature, webmock_response)
+          {lib: :httpclient}, request_signature, webmock_response)
         res
       elsif WebMock.net_connect_allowed?(request_signature.uri)
+        # in case there is a nil entry in the hash...
+        synchronize_request_response { webmock_responses.delete(request_signature) }
+
         res = if stream
           do_get_stream_without_webmock(req, proxy, conn, &block)
+        elsif block
+          body = ''
+          do_get_block_without_webmock(req, proxy, conn) do |http_res, chunk|
+            if chunk && chunk.bytesize > 0
+              body += chunk
+              block.call(http_res, chunk)
+            end
+          end
         else
-          do_get_block_without_webmock(req, proxy, conn, &block)
+          do_get_block_without_webmock(req, proxy, conn)
         end
         res = conn.pop
         conn.push(res)
         if WebMock::CallbackRegistry.any_callbacks?
-          webmock_response = build_webmock_response(res)
+          webmock_response = build_webmock_response(res, body)
           WebMock::CallbackRegistry.invoke_callbacks(
-            {:lib => :httpclient, :real_request => true}, request_signature,
+            {lib: :httpclient, real_request: true}, request_signature,
             webmock_response)
         end
         res
@@ -72,30 +100,21 @@ if defined?(::HTTPClient)
       end
     end
 
-    def do_request_async_with_webmock(method, uri, query, body, extheader)
+    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)
-        do_request_async_without_webmock(method, uri, query, body, extheader)
+        super
       else
         raise WebMock::NetConnectNotAllowedError.new(request_signature)
       end
     end
 
-    alias_method :do_get_block_without_webmock, :do_get_block
-    alias_method :do_get_block, :do_get_block_with_webmock
-
-    alias_method :do_get_stream_without_webmock, :do_get_stream
-    alias_method :do_get_stream, :do_get_stream_with_webmock
-
-    alias_method :do_request_async_without_webmock, :do_request_async
-    alias_method :do_request_async, :do_request_async_with_webmock
-
-    def build_httpclient_response(webmock_response, stream = false, &block)
+    def build_httpclient_response(webmock_response, stream = false, req_header = nil, &block)
       body = stream ? StringIO.new(webmock_response.body) : webmock_response.body
-      response = HTTP::Message.new_response(body)
+      response = HTTP::Message.new_response(body, req_header)
       response.header.init_response(webmock_response.status[0])
       response.reason=webmock_response.status[1]
       webmock_response.headers.to_a.each { |name, value| response.header.set(name, value) }
@@ -103,91 +122,138 @@ if defined?(::HTTPClient)
       raise HTTPClient::TimeoutError if webmock_response.should_timeout
       webmock_response.raise_error_if_any
 
-      block.call(response, body) if block
+      block.call(response, body) if block && body && body.bytesize > 0
 
       response
     end
-  end
 
-  def build_webmock_response(httpclient_response)
-    webmock_response = WebMock::Response.new
-    webmock_response.status = [httpclient_response.status, httpclient_response.reason]
-
-    webmock_response.headers = {}.tap do |hash|
-      httpclient_response.header.all.each do |(key, value)|
-        if hash.has_key?(key)
-          hash[key] = Array(hash[key]) + [value]
-        else
-          hash[key] = value
+    def build_webmock_response(httpclient_response, body = nil)
+      webmock_response = WebMock::Response.new
+      webmock_response.status = [httpclient_response.status, httpclient_response.reason]
+
+      webmock_response.headers = {}.tap do |hash|
+        httpclient_response.header.all.each do |(key, value)|
+          if hash.has_key?(key)
+            hash[key] = Array(hash[key]) + [value]
+          else
+            hash[key] = value
+          end
         end
       end
-    end
 
-    if  httpclient_response.content.respond_to?(:read)
-      webmock_response.body = httpclient_response.content.read
-      body = HTTP::Message::Body.new
-      body.init_response(StringIO.new(webmock_response.body))
-      httpclient_response.body = body
-    else
-      webmock_response.body = httpclient_response.content
+      if body
+        webmock_response.body = body
+      elsif httpclient_response.content.respond_to?(:read)
+        webmock_response.body = httpclient_response.content.read
+        body = HTTP::Message::Body.new
+        body.init_response(StringIO.new(webmock_response.body))
+        httpclient_response.body = body
+      else
+        webmock_response.body = httpclient_response.content
+      end
+      webmock_response
     end
-    webmock_response
-  end
 
-  def build_request_signature(req, reuse_existing = false)
-    uri = WebMock::Util::URI.heuristic_parse(req.header.request_uri.to_s)
-    uri.query_values = req.header.request_query if req.header.request_query
-    uri.port = req.header.request_uri.port
-    uri = uri.omit(:userinfo)
+    def build_request_signature(req, reuse_existing = false)
+      uri = WebMock::Util::URI.heuristic_parse(req.header.request_uri.to_s)
+      uri.query = WebMock::Util::QueryMapper.values_to_query(req.header.request_query, notation: WebMock::Config.instance.query_values_notation) if req.header.request_query
+      uri.port = req.header.request_uri.port
+
+      @request_filter.each do |filter|
+        filter.filter_request(req)
+      end
+
+      headers = req.header.all.inject({}) do |hdrs, header|
+        hdrs[header[0]] ||= []
+        hdrs[header[0]] << header[1]
+        hdrs
+      end
+      headers = headers_from_session(uri).merge(headers)
+
+      signature = WebMock::RequestSignature.new(
+        req.header.request_method.downcase.to_sym,
+        uri.to_s,
+        body: req.http_body.dump,
+        headers: headers
+      )
+
+      # reuse a previous identical signature object if we stored one for later use
+      if reuse_existing && previous_signature = previous_signature_for(signature)
+        return previous_signature
+      end
 
-    auth = www_auth.basic_auth
-    auth.challenge(req.header.request_uri, nil)
+      signature
+    end
 
-    @request_filter.each do |filter|
-      filter.filter_request(req)
+    def webmock_responses
+      @webmock_responses ||= Hash.new do |hash, request_signature|
+        synchronize_request_response do
+          hash[request_signature] = WebMock::StubRegistry.instance.response_for_request(request_signature)
+        end
+      end
     end
 
-    headers = req.header.all.inject({}) do |hdrs, header|
-      hdrs[header[0]] ||= []
-      hdrs[header[0]] << header[1]
-      hdrs
+    def webmock_request_signatures
+      @webmock_request_signatures ||= []
     end
 
-    if (auth_cred = auth.get(req)) && auth.scheme == 'Basic'
-      userinfo = WebMock::Util::Headers.decode_userinfo_from_header(auth_cred)
-      userinfo = WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)
-      headers.reject! {|k,v| k =~ /[Aa]uthorization/ && v =~ /^Basic / } #we added it to url userinfo
-      uri.userinfo = userinfo
+    def previous_signature_for(signature)
+      synchronize_request_response do
+        return nil unless index = webmock_request_signatures.index(signature)
+        webmock_request_signatures.delete_at(index)
+      end
     end
 
-    signature = WebMock::RequestSignature.new(
-      req.header.request_method.downcase.to_sym,
-      uri.to_s,
-      :body => req.content,
-      :headers => headers
-    )
+    private
 
-    # reuse a previous identical signature object if we stored one for later use
-    if reuse_existing && previous_signature = previous_signature_for(signature)
-      return previous_signature
+    # some of the headers sent by HTTPClient are derived from
+    # the client session
+    def headers_from_session(uri)
+      session_headers = HTTP::Message::Headers.new
+      @session_manager.send(:open, uri).send(:set_header, MessageMock.new(session_headers))
+      session_headers.all.inject({}) do |hdrs, header|
+        hdrs[header[0]] = header[1]
+        hdrs
+      end
     end
 
-    signature
+    def synchronize_request_response
+      if REQUEST_RESPONSE_LOCK.owned?
+        yield
+      else
+        REQUEST_RESPONSE_LOCK.synchronize do
+          yield
+        end
+      end
+    end
   end
 
-  def webmock_responses
-    @webmock_responses ||= Hash.new do |hash, request_signature|
-      hash[request_signature] = WebMock::StubRegistry.instance.response_for_request(request_signature)
-    end
+  class WebMockHTTPClient < HTTPClient
+    alias_method :do_get_block_without_webmock, :do_get_block
+    alias_method :do_get_stream_without_webmock, :do_get_stream
+
+    include WebMockHTTPClients
   end
 
-  def webmock_request_signatures
-    @webmock_request_signatures ||= []
+  if defined? ::JSONClient
+    class WebMockJSONClient < JSONClient
+      alias_method :do_get_block_without_webmock, :do_get_block
+      alias_method :do_get_stream_without_webmock, :do_get_stream
+
+      include WebMockHTTPClients
+    end
   end
 
-  def previous_signature_for(signature)
-    return nil unless index = webmock_request_signatures.index(signature)
-    webmock_request_signatures.delete_at(index)
+
+  # Mocks a HTTPClient HTTP::Message
+  class MessageMock
+    attr_reader :header
+
+    def initialize(headers)
+      @header = headers
+    end
+
+    def http_version=(value);end
   end
 
 end

data/lib/webmock/http_lib_adapters/manticore_adapter.rb

@@ -0,0 +1,145 @@
+begin
+  require 'manticore'
+rescue LoadError
+  # manticore not found
+end
+
+if defined?(Manticore)
+  module WebMock
+    module HttpLibAdapters
+      class ManticoreAdapter < HttpLibAdapter
+        adapter_for :manticore
+
+        OriginalManticoreClient = Manticore::Client
+
+        def self.enable!
+          Manticore.send(:remove_const, :Client)
+          Manticore.send(:const_set, :Client, WebMockManticoreClient)
+          Manticore.instance_variable_set(:@manticore_facade, WebMockManticoreClient.new)
+        end
+
+        def self.disable!
+          Manticore.send(:remove_const, :Client)
+          Manticore.send(:const_set, :Client, OriginalManticoreClient)
+          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))
+          end
+
+          private
+
+          def format_options(options)
+            return options unless headers = options[:headers]
+
+            options.merge(headers: join_array_values(headers))
+          end
+
+          def join_array_values(headers)
+            headers.reduce({}) do |h, (k,v)|
+              v = v.join(', ') if v.is_a?(Array)
+              h.merge(k => v)
+            end
+          end
+
+          def response_object_for(request, context, &block)
+            request_signature = generate_webmock_request_signature(request, context)
+            WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+            if webmock_response = registered_response_for(request_signature)
+              webmock_response.raise_error_if_any
+              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)
+              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
+
+            manticore_response
+          end
+
+          def registered_response_for(request_signature)
+            WebMock::StubRegistry.instance.response_for_request(request_signature)
+          end
+
+          def real_request_allowed?(uri)
+            WebMock.net_connect_allowed?(uri)
+          end
+
+          def generate_webmock_request_signature(request, context)
+            method = request.method.downcase
+            uri = request.uri.to_s
+            body = read_body(request)
+            headers = split_array_values(request.headers)
+
+            if context.get_credentials_provider && credentials = context.get_credentials_provider.get_credentials(AuthScope::ANY)
+              headers['Authorization'] = WebMock::Util::Headers.basic_auth_header(credentials.get_user_name,credentials.get_password)
+            end
+
+            WebMock::RequestSignature.new(method, uri, {body: body, headers: headers})
+          end
+
+          def read_body(request)
+            if request.respond_to?(:entity) && !request.entity.nil?
+              Manticore::EntityConverter.new.read_entity(request.entity)
+            end
+          end
+
+          def split_array_values(headers = [])
+            headers.each_with_object({}) do |(k, v), h|
+              h[k] = case v
+                     when /,/ then v.split(',').map(&:strip)
+                     else v
+                     end
+            end
+          end
+
+          def generate_manticore_response(webmock_response)
+            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.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
+      end
+    end
+  end
+end