webmock 3.14.0 → 3.18.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8f150fbeccca419468dfebe632e3b5d365cb8c2df9a5e2a31e65591298786fb
-  data.tar.gz: d92950bc5ae3510e599c40545f3e7a0ebaafa54a698f79a3c82243e240d35948
+  metadata.gz: 3a7e964f28dd42787fd854c5fcc87dba4cd61ef214c3dee485d9bd0d71fc1cdd
+  data.tar.gz: f6921a9b14ccd71f18b4674aca8d4d24bf377545a4ef8c56862f95cc56b6e8a7
 SHA512:
-  metadata.gz: f58d569f7c633d758cee725e5dafb39edacb74e0017ba9c29de0cad8fe16d1f7740cc30847a9f129f6571232d2ca8172d7fb76a1eb3383e31ee8371472f141f9
-  data.tar.gz: 52191c4e12ac3bf79b575f36d58823ea37ab17f83c7a62602889f361eafadabfa4b0b8ffc1f466eee6de53ea77578fc0149a60e14abdd8a7459b651afbeb85d0
+  metadata.gz: 80e85d1bb83018bdaab80aed649134757ee8ac591b98e9ccf1b6df10c0d8930db167dd5fd3bb039dd56a955d22c0cc6b1a1227bb88e8f3e56d31d0e1c9d7708e
+  data.tar.gz: c67f1f8486d6ee932bd9d01dff2bfcec35d9c3e3ed937e50e1f56d34f664ca11db4c9399c51e82da9316245c1d4727c726b9e307646aef80477764609ecf95ee

data/.github/workflows/CI.yml

@@ -14,6 +14,7 @@ jobs:
       matrix:
         ruby:
           - head
+          - '3.1'
           - '3.0'
           - '2.7'
           - '2.6'

data/CHANGELOG.md

@@ -1,5 +1,89 @@
 # Changelog
 
+# 3.18.1
+
+  * Reverted simplified connection handing in Net::HTTP adapter due to https://github.com/bblimke/webmock/issues/999
+
+# 3.18.0
+
+  * Net::BufferedIO is not replaced anymore.
+
+    Thanks to [Ray Zane](https://github.com/rzane)
+
+  * Simplified connection handing in Net::HTTP adapter.
+
+    Thanks to [Ray Zane](https://github.com/rzane)
+
+# 3.17.1
+
+  * Fixed Syntax Error
+
+    Thanks to [Mark Spangler](https://github.com/mspangler)
+
+# 3.17.0
+
+  * Minimum required Ruby version is 2.3
+
+    Thanks to [Go Sueyoshi](https://github.com/sue445)
+
+  * When using Net::HTTP, stubbed socket StubSocket#close and StubSocket#closed? behave more like the real sockets.
+
+    Thanks to [Ray Zane](https://github.com/rzane)
+
+  * Added `peeraddr`, `ssl_version` and `cipher` methods to stubbed sockets used by Net::HTTP.
+
+    Thanks to [Ray Zane](https://github.com/rzane)
+
+  * Added support for matching top-level array in JSON request body.
+
+    E.g.
+
+      ````
+      stub_request(:post, 'www.example.com').with(body: [{a: 1}])
+      ````
+
+    Thanks to [Cedric Sohrauer](https://github.com/cedrics)
+
+# 3.16.2
+
+  * Minimum required Ruby version is 2.0.
+
+# 3.16.0 (yanked)
+
+  * Fix leaky file descriptors and reuse socket for persistent connections.
+
+    Thanks to [Ray Zane](https://github.com/rzane)
+
+  * Allow specifying for what URIs or hosts, Net::HTTP should connect on start.
+
+    Thanks to [Ray Zane](https://github.com/rzane)
+
+# 3.15.2
+
+  * Minimum required Ruby version is 2.0.
+
+# 3.15.0 (yanked)
+
+  * fixed async-http adapter on Windows
+
+    Thanks to [Pavel Rosický](https://github.com/ahorek)
+
+  * Support for http.rb >= 5.0.2
+
+    Thanks to [ojab](https://github.com/ojab)
+
+  * Curb adapter supports headers with `:` character in the header value
+
+    Thanks to [Giorgio Gambino](https://github.com/mrbuzz)
+
+  * Support for matching body of JSON or application/x-www-form-urlencoded requests with content type header including charset.
+
+    Thanks to [Timmitry](https://github.com/Timmitry)
+
+  * Prevent double-wrapping http.rb features on non-stubbed requests
+
+    Thanks to [Michael Fairley](https://github.com/michaelfairley)
+
 # 3.14.0
 
   * Bump Addressable from 2.3.6 to 2.8.0
@@ -605,9 +689,9 @@
   * `WebMock.disable_net_connect` accepts `:allow` option with an object that responds to `#call`, receiving a `URI` object and returning a boolean:
 
 
-        blacklist = ['google.com', 'facebook.com', 'apple.com']
+        denylist = ['google.com', 'facebook.com', 'apple.com']
         allowed_sites = lambda{|uri|
-          blacklist.none?{|site| uri.host.include?(site) }
+          denylist.none?{|site| uri.host.include?(site) }
         }
         WebMock.disable_net_connect!(:allow => allowed_sites)
 

data/README.md

@@ -550,9 +550,9 @@ RestClient.get('sample.org', '/bar')          # ===> Failure
 With an object that responds to `#call`, receiving a `URI` object and returning a boolean:
 
 ```ruby
-blacklist = ['google.com', 'facebook.com', 'apple.com']
+denylist = ['google.com', 'facebook.com', 'apple.com']
 allowed_sites = lambda{|uri|
-  blacklist.none?{|site| uri.host.include?(site) }
+  denylist.none?{|site| uri.host.include?(site) }
 }
 WebMock.disable_net_connect!(allow: allowed_sites)
 
@@ -1161,13 +1161,22 @@ People who submitted patches and new features or suggested improvements. Many th
 * Alex Vondrak
 * Will Storey
 * Eduardo Hernandez
+* ojab
+* Giorgio Gambino
+* Timmitry
+* Michael Fairley
+* Ray Zane
+* Go Sueyoshi
+* Cedric Sohrauer
+* Akira Matsuda
+* Mark Spangler
 
 For a full list of contributors you can visit the
 [contributors](https://github.com/bblimke/webmock/contributors) page.
 
 ## Background
 
-Thank you Fakeweb! This library was inspired by [FakeWeb](http://fakeweb.rubyforge.org).
+Thank you Fakeweb! This library was inspired by [FakeWeb](https://github.com/chrisk/fakeweb).
 I imported some solutions from that project to WebMock. I also copied some code i.e Net:HTTP adapter.
 Fakeweb architecture unfortunately didn't allow me to extend it easily with the features I needed.
 I also preferred some things to work differently i.e request stub precedence.

data/lib/webmock/http_lib_adapters/async_http_client_adapter.rb

@@ -151,7 +151,12 @@ if defined?(Async::HTTP)
         private
 
         def create_connected_sockets
-          Async::IO::Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM).tap do |sockets|
+          pair = begin
+            Async::IO::Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM)
+          rescue Errno::EAFNOSUPPORT
+            Async::IO::Socket.pair(Socket::AF_INET, Socket::SOCK_STREAM)
+          end
+          pair.tap do |sockets|
             sockets.each do |socket|
               socket.instance_variable_set :@alpn_protocol, nil
               socket.instance_eval do

data/lib/webmock/http_lib_adapters/curb_adapter.rb

@@ -5,7 +5,7 @@ rescue LoadError
 end
 
 if defined?(Curl)
-  WebMock::VersionChecker.new('Curb', Curl::CURB_VERSION, '0.7.16', '0.9.1', ['0.8.7']).check_version!
+  WebMock::VersionChecker.new('Curb', Curl::CURB_VERSION, '0.7.16', '1.0.1', ['0.8.7']).check_version!
 
   module WebMock
     module HttpLibAdapters
@@ -128,7 +128,7 @@ if defined?(Curl)
       def headers_as_hash(headers)
         if headers.is_a?(Array)
           headers.inject({}) {|hash, header|
-            name, value = header.split(":").map(&:strip)
+            name, value = header.split(":", 2).map(&:strip)
             hash[name] = value
             hash
           }

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

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

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

@@ -24,7 +24,10 @@ module HTTP
         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)
+          Body.new(
+            Streamer.new(webmock_response.body, encoding: webmock_response.body.encoding),
+            encoding: webmock_response.body.encoding
+          )
         end
 
         return new(status, "1.1", headers, body, uri) if HTTP::VERSION < "1.0.0"

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

@@ -1,8 +1,9 @@
 module HTTP
   class Response
     class Streamer
-      def initialize(str)
+      def initialize(str, encoding: Encoding::BINARY)
         @io = StringIO.new str
+        @encoding = encoding
       end
 
       def readpartial(size = nil, outbuf = nil)
@@ -14,7 +15,8 @@ module HTTP
           end
         end
 
-        @io.read size, outbuf
+        chunk = @io.read size, outbuf
+        chunk.force_encoding(@encoding) if chunk
       end
 
       def close

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

@@ -1,7 +1,8 @@
 module HTTP
   class WebMockPerform
-    def initialize(request, &perform)
+    def initialize(request, options, &perform)
       @request = request
+      @options = options
       @perform = perform
       @request_signature = nil
     end
@@ -38,7 +39,10 @@ module HTTP
       webmock_response.raise_error_if_any
 
       invoke_callbacks(webmock_response, real_request: false)
-      ::HTTP::Response.from_webmock @request, webmock_response, request_signature
+      response = ::HTTP::Response.from_webmock @request, webmock_response, request_signature
+
+      @options.features.each { |_name, feature| response = feature.wrap_response(response) }
+      response
     end
 
     def raise_timeout_error

data/lib/webmock/http_lib_adapters/net_http.rb

@@ -10,24 +10,19 @@ module WebMock
       adapter_for :net_http
 
       OriginalNetHTTP = Net::HTTP unless const_defined?(:OriginalNetHTTP)
-      OriginalNetBufferedIO = Net::BufferedIO unless const_defined?(:OriginalNetBufferedIO)
 
       def self.enable!
-        Net.send(:remove_const, :BufferedIO)
         Net.send(:remove_const, :HTTP)
         Net.send(:remove_const, :HTTPSession)
         Net.send(:const_set, :HTTP, @webMockNetHTTP)
         Net.send(:const_set, :HTTPSession, @webMockNetHTTP)
-        Net.send(:const_set, :BufferedIO, Net::WebMockNetBufferedIO)
       end
 
       def self.disable!
-        Net.send(:remove_const, :BufferedIO)
         Net.send(:remove_const, :HTTP)
         Net.send(:remove_const, :HTTPSession)
         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
@@ -98,13 +93,8 @@ module WebMock
               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
+              ensure_actual_connection
+              super_with_after_request.call
             else
               start_with_connect {
                 super_with_after_request.call
@@ -119,32 +109,33 @@ module WebMock
           raise IOError, 'HTTP session already opened' if @started
           if block_given?
             begin
+              @socket = Net::HTTP.socket_type.new
               @started = true
               return yield(self)
             ensure
               do_finish
             end
           end
+          @socket = Net::HTTP.socket_type.new
           @started = true
           self
         end
 
 
-        def start_with_connect_without_finish  # :yield: http
-          if block_given?
-            begin
-              do_start
-              return yield(self)
-            end
+        def ensure_actual_connection
+          if @socket.is_a?(StubSocket)
+            @socket&.close
+            @socket = nil
+            do_start
           end
-          do_start
-          self
         end
 
         alias_method :start_with_connect, :start
 
         def start(&block)
-          if WebMock::Config.instance.net_http_connect_on_start
+          uri = Addressable::URI.parse(WebMock::NetHTTPUtility.get_uri(self))
+
+          if WebMock.net_http_connect_on_start?(uri)
             super(&block)
           else
             start_without_connect(&block)
@@ -169,7 +160,7 @@ module WebMock
           response.extend Net::WebMockHTTPResponse
 
           if webmock_response.should_timeout
-            raise timeout_exception, "execution expired"
+            raise Net::OpenTimeout, "execution expired"
           end
 
           webmock_response.raise_error_if_any
@@ -179,16 +170,6 @@ 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 = [
@@ -222,31 +203,21 @@ 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, :continue_timeout, :write_timeout
 
   def initialize(*args)
+    @closed = false
   end
 
   def closed?
-    @closed ||= true
+    @closed
   end
 
   def close
+    @closed = true
+    nil
   end
 
   def readuntil(*args)
@@ -258,57 +229,13 @@ class StubSocket #:nodoc:
 
   class StubIO
     def setsockopt(*args); end
+    def peer_cert; end
+    def peeraddr; ["AF_INET", 443, "127.0.0.1", "127.0.0.1"] end
+    def ssl_version; "TLSv1.3" end
+    def cipher; ["TLS_AES_128_GCM_SHA256", "TLSv1.3", 128, 128] end
   end
 end
 
-module Net  #:nodoc: all
-
-  class WebMockNetBufferedIO < BufferedIO
-    def initialize(io, *args, **kwargs)
-      io = case io
-      when Socket, OpenSSL::SSL::SSLSocket, IO
-        io
-      when StringIO
-        PatchedStringIO.new(io.string)
-      when String
-        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
-    end
-  end
-
-end
-
-
 module WebMock
   module NetHTTPUtility
 
@@ -325,7 +252,6 @@ module WebMock
       method = request.method.downcase.to_sym
 
       headers = Hash[*request.to_hash.map {|k,v| [k, v]}.inject([]) {|r,x| r + x}]
-      validate_headers(headers)
 
       if request.body_stream
         body = request.body_stream.read
@@ -341,7 +267,7 @@ module WebMock
       WebMock::RequestSignature.new(method, uri, body: request.body, headers: headers)
     end
 
-    def self.get_uri(net_http, path)
+    def self.get_uri(net_http, path = nil)
       protocol = net_http.use_ssl? ? "https" : "http"
 
       hostname = net_http.address
@@ -350,25 +276,6 @@ module WebMock
       "#{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)
     end

data/lib/webmock/request_pattern.rb

@@ -281,6 +281,8 @@ module WebMock
       if (@pattern).is_a?(Hash)
         return true if @pattern.empty?
         matching_body_hashes?(body_as_hash(body, content_type), @pattern, content_type)
+      elsif (@pattern).is_a?(Array)
+        matching_body_array?(body_as_hash(body, content_type), @pattern, content_type)
       elsif (@pattern).is_a?(WebMock::Matchers::HashIncludingMatcher)
         @pattern == body_as_hash(body, content_type)
       else
@@ -344,19 +346,33 @@ module WebMock
     def matching_body_hashes?(query_parameters, pattern, content_type)
       return false unless query_parameters.is_a?(Hash)
       return false unless query_parameters.keys.sort == pattern.keys.sort
-      query_parameters.each do |key, actual|
+
+      query_parameters.all? do |key, actual|
         expected = pattern[key]
+        matching_values(actual, expected, content_type)
+      end
+    end
 
-        if actual.is_a?(Hash) && expected.is_a?(Hash)
-          return false unless matching_body_hashes?(actual, expected, content_type)
-        else
-          expected = WebMock::Util::ValuesStringifier.stringify_values(expected) if url_encoded_body?(content_type)
-          return false unless expected === actual
-        end
+    def matching_body_array?(query_parameters, pattern, content_type)
+      return false unless query_parameters.is_a?(Array)
+      return false unless query_parameters.length == pattern.length
+
+      query_parameters.each_with_index do |actual, index|
+        expected = pattern[index]
+        return false unless matching_values(actual, expected, content_type)
       end
+
       true
     end
 
+    def matching_values(actual, expected, content_type)
+      return matching_body_hashes?(actual, expected, content_type) if actual.is_a?(Hash) && expected.is_a?(Hash)
+      return matching_body_array?(actual, expected, content_type) if actual.is_a?(Array) && expected.is_a?(Array)
+
+      expected = WebMock::Util::ValuesStringifier.stringify_values(expected) if url_encoded_body?(content_type)
+      expected === actual
+    end
+
     def empty_string?(string)
       string.nil? || string == ""
     end

data/lib/webmock/request_signature.rb

@@ -35,11 +35,11 @@ module WebMock
     alias == eql?
 
     def url_encoded?
-      !!(headers && headers['Content-Type'] == 'application/x-www-form-urlencoded')
+      !!(headers&.fetch('Content-Type', nil)&.start_with?('application/x-www-form-urlencoded'))
     end
 
     def json_headers?
-      !!(headers && headers['Content-Type'] == 'application/json')
+      !!(headers&.fetch('Content-Type', nil)&.start_with?('application/json'))
     end
 
     private

data/lib/webmock/request_stub.rb

@@ -24,6 +24,21 @@ module WebMock
     end
     alias_method :and_return, :to_return
 
+    def to_return_json(*response_hashes)
+      raise ArgumentError, '#to_return_json does not support passing a block' if block_given?
+
+      json_response_hashes = [*response_hashes].flatten.map do |resp_h|
+        headers, body = resp_h.values_at(:headers, :body)
+        resp_h.merge(
+          headers: {content_type: 'application/json'}.merge(headers.to_h),
+          body: body.is_a?(Hash) ? body.to_json : body
+        )
+      end
+
+      to_return(json_response_hashes)
+    end
+    alias_method :and_return_json, :to_return_json
+
     def to_rack(app, options={})
       @responses_sequences << ResponsesSequence.new([RackResponse.new(app)])
     end

data/lib/webmock/response.rb

@@ -14,8 +14,11 @@ module WebMock
 
   class Response
     def initialize(options = {})
-      if options.is_a?(IO) || options.is_a?(String)
+      case options
+      when IO, StringIO
         self.options = read_raw_response(options)
+      when String
+        self.options = read_raw_response(StringIO.new(options))
       else
         self.options = options
       end
@@ -120,13 +123,8 @@ module WebMock
       end
     end
 
-    def read_raw_response(raw_response)
-      if raw_response.is_a?(IO)
-        string = raw_response.read
-        raw_response.close
-        raw_response = string
-      end
-      socket = ::Net::BufferedIO.new(raw_response)
+    def read_raw_response(io)
+      socket = ::Net::BufferedIO.new(io)
       response = ::Net::HTTPResponse.read_new(socket)
       transfer_encoding = response.delete('transfer-encoding') #chunks were already read by curl
       response.reading_body(socket, true) {}
@@ -138,6 +136,8 @@ module WebMock
       options[:body] = response.read_body
       options[:status] = [response.code.to_i, response.message]
       options
+    ensure
+      socket.close
     end
 
     InvalidBody = Class.new(StandardError)

data/lib/webmock/version.rb

@@ -1,3 +1,3 @@
 module WebMock
-  VERSION = '3.14.0' unless defined?(::WebMock::VERSION)
+  VERSION = '3.18.1' unless defined?(::WebMock::VERSION)
 end

data/lib/webmock/webmock.rb

@@ -70,6 +70,16 @@ module WebMock
       Config.instance.allow && net_connect_explicit_allowed?(Config.instance.allow, uri) )
   end
 
+  def self.net_http_connect_on_start?(uri)
+    allowed = Config.instance.net_http_connect_on_start || false
+
+    if [true, false].include?(allowed)
+      allowed
+    else
+      net_connect_explicit_allowed?(allowed, uri)
+    end
+  end
+
   def self.net_connect_explicit_allowed?(allowed, uri=nil)
     case allowed
     when Array

data/minitest/webmock_spec.rb

@@ -20,7 +20,7 @@ require File.expand_path(File.dirname(__FILE__) + '/test_helper')
     end
 
     it "should raise error on non stubbed request" do
-      lambda { http_request(:get, "http://www.example.net/") }.must_raise(WebMock::NetConnectNotAllowedError)
+      expect { http_request(:get, "http://www.example.net/") }.must_raise(WebMock::NetConnectNotAllowedError)
     end
 
     it "should verify that expected request occured" do