webmock 3.6.0 → 3.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 137bc694f0b4f457b84a5fc6f93a7b2227ff19bcb6e8bd1525244649df56898c
-  data.tar.gz: f998d2cd340cffd2637bcc3cf8cfe322c85de1055d07b51c7e193acde549d340
+  metadata.gz: 6023ac450eb0fc7d307ffd764f811e9d409e28fdfabdb215bec15d4e4ea7a363
+  data.tar.gz: 2417fb3aecf50a9b48dc84ee1eb55da9493cff52c68c8a292e0d9215f1c52379
 SHA512:
-  metadata.gz: 9b36a8ce4d2b4b779e89f5e7db1ed1c8e17817f1088fcd9d92e8f2154373a254292240dffc0d7f376fb86c1230f0371aefa6a56163710cc2ed86301915270b52
-  data.tar.gz: 54d26c28e44ebec703628a4473f4bc1547f7c6fad2eeefbffea77398fed62759f131f94bd7fceb78275a8be70d30c94586383ecb43c1f16882a8dfe4e89dcf53
+  metadata.gz: a83cdbc53a9c75e6d4db3f01e727cc2cb27fb8097dfbad2cd36b39e263bfdc570f60b1c2b924845f81bff2c89dbd91758061c830293c86d0f3a2ba2bb01d619a
+  data.tar.gz: 07cc56e80c126f76ecd53a00b218e80c0a07760d478b1d8354d85f7057828256f4dcc2e857312c83a2bfadbdbcfda0bb20c82510949cabdb24fd3f50657fffbb

data/.travis.yml

@@ -5,12 +5,13 @@ rvm:
   - 2.3.8
   - 2.4.6
   - 2.5.5
-  - 2.6.2
+  - 2.6.3
   - rbx-2
   - ruby-head
   - jruby-9.1.17.0
-  - jruby-9.2.6.0
+  - jruby-9.2.7.0
   - jruby-head
+jdk: openjdk8
 matrix:
   allow_failures:
     - rvm: jruby-head

data/CHANGELOG.md

@@ -1,5 +1,61 @@
 # Changelog
 
+## 3.7.3
+
+  * Fix for http.rb. Allow passing an output buffer to HTTP::Response::Body#readpartial
+
+    Thanks to [George Claghorn](https://github.com/georgeclaghorn)
+
+  * Fixed Manticore adapter to invoke Manticore failure handler on stubbed timeout
+
+    Thanks to [Alex Junger](https://github.com/alexJunger)
+
+  * Added project metadata to the gemspec
+
+    Thanks to [Orien Madgwick](https://github.com/orien)
+
+## 3.7.2
+
+  * Fixed handling of non UTF-8 encoded urls
+
+    Thanks to [Rafael França](https://github.com/rafaelfranca)
+
+  * Fixed "shadowing outer local variable" warning
+
+    Thanks to [y-yagi](https://github.com/y-yagi)
+
+## 3.7.1
+
+  * Fixed Async::HTTP::Client adapter code to not cause Ruby warning
+
+    Thanks to [y-yagi](https://github.com/y-yagi)
+
+## 3.7.0
+
+  * Support for Async::HTTP::Client
+
+    Thanks to [Andriy Yanko](https://github.com/ayanko)
+
+## 3.6.2
+
+  * Fixed Patron adapter to handle HTTP/2 status line.
+
+    Thanks to [Fábio D. Batista](https://github.com/fabiob)
+
+## 3.6.1
+
+  * Fixed issue with matching Addressable::Template without a period in the domain
+
+    Thanks to [Eike Send](https://github.com/eikes)
+
+  * Support for `write_timeout` in Net::HTTP
+
+    Thanks to [Claudio Poli](https://github.com/masterkain)
+
+  * Fixed issue with handling urls with ":80" or ":443" in the path.
+
+    Thanks to [Csaba Apagyi](https://github.com/thisismydesign) for reporting and to [Frederick Cheung](https://github.com/fcheung) for fixing the issue.
+
 ## 3.6.0
 
   * Compatibility with the latest version of hashdiff gem, with constant changed from HashDiff to Hashdiff

data/README.md

@@ -33,6 +33,7 @@ Supported HTTP libraries
 * Excon
 * HTTP Gem
 * Manticore
+* Async::HTTP::Client
 
 Supported Ruby Interpreters
 ---------------------------
@@ -878,6 +879,10 @@ end
 
 Please submit them here [http://github.com/bblimke/webmock/issues](http://github.com/bblimke/webmock/issues)
 
+## Issue triage [![Open Source Helpers](https://www.codetriage.com/bblimke/webmock/badges/users.svg)](https://www.codetriage.com/bblimke/webmock)
+
+You can contribute by triaging issues which may include reproducing bug reports or asking for vital information, such as version numbers or reproduction instructions. If you would like to start triaging issues, one easy way to get started is to [subscribe to webmock on CodeTriage](https://www.codetriage.com/bblimke/webmock).
+
 ## Suggestions
 
 If you have any suggestions on how to improve WebMock please send an email to the mailing list [groups.google.com/group/webmock-users](http://groups.google.com/group/webmock-users)
@@ -1096,6 +1101,19 @@ People who submitted patches and new features or suggested improvements. Many th
 * Pavel Valena
 * Adam Sokolnicki
 * Jeff Felchner
+* Eike Send
+* Claudio Poli
+* Csaba Apagyi
+* Frederick Cheung
+* Fábio D. Batista
+* Andriy Yanko
+* y-yagi
+* Rafael França
+* George Claghorn
+* Alex Junger
+* Orien Madgwick
+
+
 
 For a full list of contributors you can visit the
 [contributors](https://github.com/bblimke/webmock/contributors) page.

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, protocol, scheme, authority, options)
+          @webmock_client = WebMockClient.new(webmock_endpoint, protocol, scheme, authority, 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 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, @alpn_protocol
+              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/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/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/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,14 +112,16 @@ 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)

data/lib/webmock/http_lib_adapters/net_http.rb

@@ -229,14 +229,15 @@ class PatchedStringIO < StringIO #:nodoc:
   alias_method :orig_read_nonblock, :read_nonblock
 
   def read_nonblock(size, *args)
-    orig_read_nonblock(size)
+    args.reject! {|arg| !arg.is_a?(Hash)}
+    orig_read_nonblock(size, *args)
   end
 
 end
 
 class StubSocket #:nodoc:
 
-  attr_accessor :read_timeout, :continue_timeout
+  attr_accessor :read_timeout, :continue_timeout, :write_timeout
 
   def initialize(*args)
   end