webmock 3.7.6 → 3.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 337947555c0257e2a9eb31d5af91db7a2540ad489fd27dc31ad3409e14a9b028
-  data.tar.gz: bd7cde5d8e0c7226e1c9a38303dee583ac2e974658373215b7c11396579adef2
+  metadata.gz: 603d6344674ad0d4b41e3b9fb2523d0d629f781873e0b5ac6dc72331ce30139a
+  data.tar.gz: 034c21429d7b11336d59485f198abb0b61f3dce89ec59c2298bb81d1f8cd987e
 SHA512:
-  metadata.gz: e94e7cd1f009c514204c4642ce13df9eb338fcd0cadea61347f02550606680c1605ea00b03c6453d34c89b407987b02d1b3a01c6ae9bc26ec56aec8103726999
-  data.tar.gz: 0fc2817995308a59726a703c3ab221e9aa7ee10b35909a637dfe9620c5c185d06ea5327f86234e6578568d94e7ca566df112601eb27f762d258c183b10c67dbc
+  metadata.gz: e4a36fc1d613f0187c361d4d1fed3a3c2f082496839b1af649a752916fa9e1285a8261aec34fe25a236a35d930782a5b6cd62de919481e99198390b65407577d
+  data.tar.gz: c3b93eaaa8f3a513e54d90f179ced6b48f08805232060ebd2cf41407bdd2f000d5cd8a01e584237bb634ad0ca5a00607d000ec7c257b51ebdbe96790937cc7ae

data/.travis.yml

@@ -1,21 +1,24 @@
 before_install:
-  - gem update --system
-  - gem update bundler
+  - gem update --system -N
 rvm:
-  - 2.3.8
-  - 2.4.6
   - 2.5.5
   - 2.6.3
-  - 2.6.3
-  - 2.7.0-preview1
+  - 2.7.0
   - rbx-2
   - ruby-head
-  - jruby-9.1.17.0
-  - jruby-9.2.7.0
-  - jruby-head
-jdk: openjdk8
 matrix:
+  include:
+    - rvm: jruby-9.1.17.0
+      jdk: openjdk8
+    - rvm: jruby-9.2.11.1
+      jdk: openjdk11
+    - rvm: jruby-head
+      jdk: openjdk11
   allow_failures:
     - rvm: jruby-head
     - rvm: ruby-head
     - rvm: rbx-2
+env:
+  global:
+    JRUBY_OPTS: "--debug"
+

data/CHANGELOG.md

@@ -1,5 +1,69 @@
 # Changelog
 
+## 3.9.0
+
+  * Allow using a "callable" (like a proc) as URI pattern
+
+        stub_request(:any, ->(uri) { true })
+
+    Thanks to [John Hawthorn](https://github.com/jhawthorn)
+
+  * Added stubbed IO on stubbed socket in Net::HTTP adapter.
+
+    Thanks to [Thilo Rusche](https://github.com/trusche)
+
+  * When 'webmock/rspec' is required, reset WebMock after all after(:each/example) hooks
+
+    Thanks to [Andrew Stuntz](https://github.com/drews256)
+
+  * Fixed `net_connect_allowed?` when invoked with no arguments, when there were any allowed URIs passed to `disable_net_connect?`.
+
+    Thanks to [Lucas Uyezu](https://github.com/lucasuyezu)
+
+  * Fixed async-http adapter which caused Async::HTTP::Client or Async::HTTP::Internet to hang and never return a response.
+
+    Thanks to (Bruno Sutic)[https://github.com/bruno-] and [Samuel Williams](https://github.com/ioquatix)
+
+  * Fixed warning when using async-http adapter
+
+    Thanks to (Bruno Sutic)[https://github.com/bruno-]
+
+  * Dropped support for Ruby 2.3 - EOL date: 2019-03-31
+
+  * Dropped support for Ruby 2.4 - EOL date: 2020-03-31
+
+  * Handling matching of Addressable::Template patterns that have an ip address without port and patterns that have ip address and don’t have schema and path.
+
+    Thanks to (Rafael França)[https://github.com/rafaelfranca] and (guppy0356)[https://github.com/guppy0356]
+
+## 3.8.3
+
+  * Fixed problem introduced in version 3.4.2, which caused matching against Addressable::Template representing host part of the URI to raise an error.
+
+    Thanks to [Vesa Laakso](https://github.com/valscion)
+
+## 3.8.2
+
+  * Support correct encoding parameter for HTTP.rb 2.x and earlier
+
+    Thanks to [Alex Coomans](https://github.com/drcapulet)
+
+## 3.8.1
+
+  * Added support for mocking non-ASCII bodies when making requests with HTTP.rb
+
+    Thanks to [Patrik Ragnarsson](https://github.com/dentarg)
+
+## 3.8.0
+
+  * Fixed options handling when initialising Async::HTTP::Client
+
+    Thanks to [Samuel Williams](https://github.com/ioquatix)
+
+  * Ruby 2.7 support.
+
+    Thanks to [Ryan Davis](https://github.com/zenspider) and [Brandur](https://github.com/brandur)
+
 ## 3.7.6
 
   * Suppressed keyword argument warnings in Ruby 2.7 in async-http adapter.

data/README.md

@@ -38,9 +38,6 @@ Supported HTTP libraries
 Supported Ruby Interpreters
 ---------------------------
 
-* MRI 2.2
-* MRI 2.3
-* MRI 2.4
 * MRI 2.5
 * MRI 2.6
 * MRI 2.7
@@ -243,6 +240,12 @@ stub_request(:any, /example/)
 Net::HTTP.get('www.example.com', '/')    # ===> Success
 ```
 
+### Matching uris using lambda
+
+```ruby
+stub_request(:any, ->(uri) { true })
+```
+
 ### Matching uris using RFC 6570 - Basic Example
 
 ```ruby
@@ -300,6 +303,12 @@ stub_request(:any, "www.example.com").
 Net::HTTP.get("www.example.com", '/')    # ===> "abc"
 ```
 
+Set appropriate Content-Type for HTTParty's `parsed_response`.
+
+```ruby
+stub_request(:any, "www.example.com").to_return body: '{}', headers: {content_type: 'application/json'}
+```
+
 ### Response with body specified as IO object
 
 ```ruby
@@ -1115,6 +1124,18 @@ People who submitted patches and new features or suggested improvements. Many th
 * Orien Madgwick
 * Andrei Sidorov
 * Marco Costa
+* Ryan Davis
+* Brandur
+* Samuel Williams
+* Patrik Ragnarsson
+* Alex Coomans
+* Vesa Laakso
+* John Hawthorn
+* guppy0356
+* Thilo Rusche
+* Andrew Stuntz
+* Lucas Uyezu
+* Bruno Sutic
 
 For a full list of contributors you can visit the
 [contributors](https://github.com/bblimke/webmock/contributors) page.

data/lib/webmock/http_lib_adapters/async_http_client_adapter.rb

@@ -36,7 +36,7 @@ if defined?(Async::HTTP)
           protocol = endpoint.protocol,
           scheme = endpoint.scheme,
           authority = endpoint.authority,
-          options = {}
+          **options
         )
           webmock_endpoint = WebMockEndpoint.new(scheme, authority, protocol)
 
@@ -136,7 +136,7 @@ if defined?(Async::HTTP)
 
         def connect
           server_socket, client_socket = create_connected_sockets
-          Async do
+          Async(transient: true) do
             accept_socket(server_socket)
           end
           client_socket
@@ -151,7 +151,7 @@ if defined?(Async::HTTP)
         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_variable_set :@alpn_protocol, nil
               socket.instance_eval do
                 def alpn_protocol
                   nil # means HTTP11 will be used for HTTPS

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/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

data/lib/webmock/request_pattern.rb

@@ -80,6 +80,8 @@ module WebMock
         URIRegexpPattern.new(uri)
       elsif uri.is_a?(Addressable::Template)
         URIAddressablePattern.new(uri)
+      elsif uri.respond_to?(:call)
+        URICallablePattern.new(uri)
       else
         URIStringPattern.new(uri)
       end
@@ -108,10 +110,10 @@ module WebMock
 
     def initialize(pattern)
       @pattern = case pattern
-      when Addressable::URI, Addressable::Template
-        pattern
+      when String
+        WebMock::Util::URI.normalize_uri(pattern)
       else
-          WebMock::Util::URI.normalize_uri(pattern)
+        pattern
       end
       @query_params = nil
     end
@@ -131,38 +133,44 @@ module WebMock
       end
     end
 
+    def matches?(uri)
+      pattern_matches?(uri) && query_params_matches?(uri)
+    end
+
     def to_s
-      str = @pattern.inspect
+      str = pattern_inspect
       str += " with query params #{@query_params.inspect}" if @query_params
       str
     end
-  end
 
-  class URIRegexpPattern  < URIPattern
-    def matches?(uri)
-      WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u| u.match(@pattern) } &&
-        (@query_params.nil? || @query_params == WebMock::Util::QueryMapper.query_to_values(uri.query, notation: Config.instance.query_values_notation))
+    private
+
+    def pattern_inspect
+      @pattern.inspect
     end
 
-    def to_s
-      str = @pattern.inspect
-      str += " with query params #{@query_params.inspect}" if @query_params
-      str
+    def query_params_matches?(uri)
+      @query_params.nil? || @query_params == WebMock::Util::QueryMapper.query_to_values(uri.query, notation: Config.instance.query_values_notation)
     end
   end
 
-  class URIAddressablePattern  < URIPattern
-    def matches?(uri)
-      if @query_params.nil?
-        # Let Addressable check the whole URI
-        matches_with_variations?(uri)
-      else
-        # WebMock checks the query, Addressable checks everything else
-        matches_with_variations?(uri.omit(:query)) &&
-          @query_params == WebMock::Util::QueryMapper.query_to_values(uri.query)
-      end
+  class URICallablePattern  < URIPattern
+    private
+
+    def pattern_matches?(uri)
+      @pattern.call(uri)
     end
+  end
 
+  class URIRegexpPattern  < URIPattern
+    private
+
+    def pattern_matches?(uri)
+      WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u| u.match(@pattern) }
+    end
+  end
+
+  class URIAddressablePattern  < URIPattern
     def add_query_params(query_params)
       @@add_query_params_warned ||= false
       if not @@add_query_params_warned
@@ -172,27 +180,57 @@ module WebMock
       super(query_params)
     end
 
-    def to_s
-      str = @pattern.pattern.inspect
-      str += " with variables #{@pattern.variables.inspect}" if @pattern.variables
-      str
+    private
+
+    def pattern_matches?(uri)
+      if @query_params.nil?
+        # Let Addressable check the whole URI
+        matches_with_variations?(uri)
+      else
+        # WebMock checks the query, Addressable checks everything else
+        matches_with_variations?(uri.omit(:query))
+      end
     end
 
-    private
+    def pattern_inspect
+      @pattern.pattern.inspect
+    end
 
     def matches_with_variations?(uri)
-      normalized_template = Addressable::Template.new(WebMock::Util::URI.heuristic_parse(@pattern.pattern))
+      template =
+        begin
+          Addressable::Template.new(WebMock::Util::URI.heuristic_parse(@pattern.pattern))
+        rescue Addressable::URI::InvalidURIError
+          Addressable::Template.new(@pattern.pattern)
+        end
+      WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u|
+        template_matches_uri?(template, u)
+      }
+    end
 
-      WebMock::Util::URI.variations_of_uri_as_strings(uri).any? { |u| normalized_template.match(u) }
+    def template_matches_uri?(template, uri)
+      template.match(uri)
+    rescue Addressable::URI::InvalidURIError
+      false
     end
   end
 
   class URIStringPattern < URIPattern
-    def matches?(uri)
+    def add_query_params(query_params)
+      super
+      if @query_params.is_a?(Hash) || @query_params.is_a?(String)
+        query_hash = (WebMock::Util::QueryMapper.query_to_values(@pattern.query, notation: Config.instance.query_values_notation) || {}).merge(@query_params)
+        @pattern.query = WebMock::Util::QueryMapper.values_to_query(query_hash, notation: WebMock::Config.instance.query_values_notation)
+        @query_params = nil
+      end
+    end
+
+    private
+
+    def pattern_matches?(uri)
       if @pattern.is_a?(Addressable::URI)
         if @query_params
-          uri.omit(:query) === @pattern &&
-          (@query_params.nil? || @query_params == WebMock::Util::QueryMapper.query_to_values(uri.query, notation: Config.instance.query_values_notation))
+          uri.omit(:query) === @pattern
         else
           uri === @pattern
         end
@@ -201,19 +239,8 @@ module WebMock
       end
     end
 
-    def add_query_params(query_params)
-      super
-      if @query_params.is_a?(Hash) || @query_params.is_a?(String)
-        query_hash = (WebMock::Util::QueryMapper.query_to_values(@pattern.query, notation: Config.instance.query_values_notation) || {}).merge(@query_params)
-        @pattern.query = WebMock::Util::QueryMapper.values_to_query(query_hash, notation: WebMock::Config.instance.query_values_notation)
-        @query_params = nil
-      end
-    end
-
-    def to_s
-      str = WebMock::Util::URI.strip_default_port_from_uri_string(@pattern.to_s)
-      str += " with query params #{@query_params.inspect}" if @query_params
-      str
+    def pattern_inspect
+      WebMock::Util::URI.strip_default_port_from_uri_string(@pattern.to_s)
     end
   end
 

data/lib/webmock/rspec.rb

@@ -33,7 +33,8 @@ RSPEC_CONFIGURER.configure { |config|
     WebMock.disable!
   end
 
-  config.after(:each) do
+  config.around(:each) do |example|
+    example.run
     WebMock.reset!
   end
 }

data/lib/webmock/stub_registry.rb

@@ -24,7 +24,7 @@ module WebMock
       # doesn't run immediately after stub.with.
       responses = {}
 
-      stub = ::WebMock::RequestStub.new(:any, /.*/).with { |request|
+      stub = ::WebMock::RequestStub.new(:any, ->(uri) { true }).with { |request|
         responses[request.object_id] = yield(request)
       }.to_return(lambda { |request| responses.delete(request.object_id) })
 

data/lib/webmock/version.rb

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

data/lib/webmock/webmock.rb

@@ -59,11 +59,13 @@ module WebMock
   end
 
   def self.net_connect_allowed?(uri = nil)
+    return !!Config.instance.allow_net_connect if uri.nil?
+
     if uri.is_a?(String)
       uri = WebMock::Util::URI.normalize_uri(uri)
     end
 
-    Config.instance.allow_net_connect ||
+    !!Config.instance.allow_net_connect ||
     ( Config.instance.allow_localhost && WebMock::Util::URI.is_uri_localhost?(uri) ||
       Config.instance.allow && net_connect_explicit_allowed?(Config.instance.allow, uri) )
   end

data/spec/acceptance/async_http_client/async_http_client_spec.rb

@@ -136,6 +136,8 @@ unless RUBY_PLATFORM =~ /java/
     end
 
     context 'scheme and protocol' do
+      let(:default_response_headers) { {} }
+
       before do
         stub_request(
           :get, "#{scheme}://www.example.com"
@@ -152,7 +154,7 @@ unless RUBY_PLATFORM =~ /java/
         specify do
           expect(subject).to eq(
             status: 200,
-            headers: {},
+            headers: default_response_headers,
             body: 'BODY'
           )
         end
@@ -169,6 +171,7 @@ unless RUBY_PLATFORM =~ /java/
 
         context 'HTTP10 protocol' do
           let(:protocol) { Async::HTTP::Protocol::HTTP10 }
+          let(:default_response_headers) { {"connection"=>["keep-alive"]} }
 
           include_examples :common
         end
@@ -197,6 +200,7 @@ unless RUBY_PLATFORM =~ /java/
 
         context 'HTTP10 protocol' do
           let(:protocol) { Async::HTTP::Protocol::HTTP10 }
+          let(:default_response_headers) { {"connection"=>["keep-alive"]} }
 
           include_examples :common
         end

data/spec/acceptance/http_rb/http_rb_spec.rb

@@ -74,13 +74,13 @@ describe "HTTP.rb" do
   context "streamer" do
     it "can be read to a provided buffer" do
       stub_request(:get, "example.com/foo")
-        .to_return(status: 200, body: "Hello world!")
+        .to_return(status: 200, body: "Hello world! ")
       response = HTTP.get "http://example.com/foo"
 
       buffer = ""
       response.body.readpartial(1024, buffer)
 
-      expect(buffer).to eq "Hello world!"
+      expect(buffer).to eq "Hello world! "
     end
 
     it "can be closed" do

data/spec/acceptance/net_http/net_http_spec.rb

@@ -201,6 +201,18 @@ describe "Net:HTTP" do
     expect(Net::HTTP.get_response(Addressable::URI.parse('http://www.example.com/hello?a=1')).body).to eq("abc")
   end
 
+  it "should support method calls on stubbed socket" do
+    WebMock.allow_net_connect!
+    stub_request(:get, 'www.google.com')#.with(headers: {"My-Header" => 99})
+    req = Net::HTTP::Get.new('/')
+    Net::HTTP.start('www.google.com') do |http|
+      http.request(req, '')
+      socket = http.instance_variable_get(:@socket)
+      expect(socket).to be_a(StubSocket)
+      expect { socket.io.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) }.to_not raise_error
+    end
+  end
+
   describe "connecting on Net::HTTP.start" do
     before(:each) do
       @http = Net::HTTP.new('www.google.com', 443)

data/spec/acceptance/shared/stubbing_requests.rb

@@ -640,4 +640,22 @@ shared_examples_for "stubbing requests" do |*adapter_info|
       }.to raise_error(WebMock::NetConnectNotAllowedError, %r(Real HTTP connections are disabled. Unregistered request: GET http://www.example.com/))
     end
   end
+
+  describe "in Rspec around(:each) hook" do
+    # order goes
+    # around(:each)
+    # before(:each)
+    # after(:each)
+    # anything after example.run in around(:each)
+    around(:each) do |example|
+      example.run
+      expect {
+        http_request(:get, "http://www.example.com/")
+      }.to_not raise_error # WebMock::NetConnectNotAllowedError
+    end
+
+    it "should still allow me to make a mocked request" do
+      stub_request(:get, "www.example.com")
+    end
+  end
 end

data/spec/unit/request_pattern_spec.rb

@@ -111,6 +111,16 @@ describe WebMock::RequestPattern do
         to match(WebMock::RequestSignature.new(:get, "www.example.com"))
     end
 
+    it "should match if uri proc pattern returning true" do
+      expect(WebMock::RequestPattern.new(:get, ->(uri) { true })).
+        to match(WebMock::RequestSignature.new(:get, "www.example.com"))
+    end
+
+    it "should not match if uri proc pattern returns false" do
+      expect(WebMock::RequestPattern.new(:get, ->(uri) { false })).
+        not_to match(WebMock::RequestSignature.new(:get, "www.example.com"))
+    end
+
     it "should match if uri Addressable::Template pattern matches unescaped form of request uri" do
       expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com/{any_path}"))).
         to match(WebMock::RequestSignature.new(:get, "www.example.com/my%20path"))
@@ -132,6 +142,30 @@ describe WebMock::RequestPattern do
       expect(WebMock::RequestPattern.new(:get, uri)).to match(signature)
     end
 
+    it "should match if Addressable::Template pattern that has ip address host without port matches request uri" do
+      signature = WebMock::RequestSignature.new(:get, "127.0.0.1/1234")
+      uri = Addressable::Template.new("127.0.0.1/{id}")
+      expect(WebMock::RequestPattern.new(:get, uri)).to match(signature)
+    end
+
+    it "should match if Addressable::Template pattern host matches request uri" do
+      signature = WebMock::RequestSignature.new(:get, "www.example.com")
+      uri = Addressable::Template.new("{subdomain}.example.com")
+      expect(WebMock::RequestPattern.new(:get, uri)).to match(signature)
+    end
+
+    it "should not match if Addressable::Template pattern host does not match request uri" do
+      signature = WebMock::RequestSignature.new(:get, "www.bad-example.com")
+      uri = Addressable::Template.new("{subdomain}.example.com")
+      expect(WebMock::RequestPattern.new(:get, uri)).not_to match(signature)
+    end
+
+    it "should match if uri Addressable::Template pattern matches request uri without a schema and a path " do
+      signature = WebMock::RequestSignature.new(:get, "127.0.0.1:3000")
+      uri = Addressable::Template.new("127.0.0.1:3000")
+      expect(WebMock::RequestPattern.new(:get, uri)).to match(signature)
+    end
+
     it "should match for uris with same parameters as pattern" do
       expect(WebMock::RequestPattern.new(:get, "www.example.com?a=1&b=2")).
         to match(WebMock::RequestSignature.new(:get, "www.example.com?a=1&b=2"))
@@ -229,6 +263,42 @@ describe WebMock::RequestPattern do
         end
       end
 
+      describe "when uri is described as a proc" do
+        it "should match request query params" do
+          expect(WebMock::RequestPattern.new(:get, ->(uri) { true }, query: {"a" => ["b", "c"]})).
+            to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
+        end
+
+        it "should match request query params if params don't match" do
+          expect(WebMock::RequestPattern.new(:get, ->(uri) { true }, query: {"x" => ["b", "c"]})).
+            not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
+        end
+
+        it "should match when query params are declared as HashIncluding matcher matching params" do
+          expect(WebMock::RequestPattern.new(:get, ->(uri) { true },
+          query: WebMock::Matchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
+            to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
+        end
+
+        it "should not match when query params are declared as HashIncluding matcher not matching params" do
+          expect(WebMock::RequestPattern.new(:get, ->(uri) { true },
+          query: WebMock::Matchers::HashIncludingMatcher.new({"x" => ["b", "c"]}))).
+            not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
+        end
+
+        it "should match when query params are declared as RSpec HashIncluding matcher matching params" do
+          expect(WebMock::RequestPattern.new(:get, ->(uri) { true },
+          query: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "c"]}))).
+            to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
+        end
+
+        it "should not match when query params are declared as RSpec HashIncluding matcher not matching params" do
+          expect(WebMock::RequestPattern.new(:get, ->(uri) { true },
+          query: RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher.new({"a" => ["b", "d"]}))).
+            not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c&b=1"))
+        end
+      end
+
       describe "when uri is described as Addressable::Template" do
         it "should raise error if query params are specified" do
           expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"), query: {"a" => ["b", "c"]})).

data/spec/unit/webmock_spec.rb

@@ -1,19 +1,60 @@
 require 'spec_helper'
 
-describe "WebMock version" do
-  it "should report version" do
-    expect(WebMock.version).to eq(WebMock::VERSION)
-  end
+describe "WebMock" do
 
-  it "should not require safe_yaml" do
-    expect(defined?SafeYAML).to eq(nil)
-  end
+  describe ".version" do
+    it "should report version" do
+      expect(WebMock.version).to eq(WebMock::VERSION)
+    end
+
+    it "should not require safe_yaml" do
+      expect(defined?SafeYAML).to eq(nil)
+    end
 
-  it "should alias enable_net_connect! to allow_net_connect!" do
-    expect(WebMock.method(:enable_net_connect!)).to eq(WebMock.method(:allow_net_connect!))
+    it "should alias enable_net_connect! to allow_net_connect!" do
+      expect(WebMock.method(:enable_net_connect!)).to eq(WebMock.method(:allow_net_connect!))
+    end
+
+    it "should alias disallow_net_connect! to disable_net_connect!" do
+      expect(WebMock.method(:disallow_net_connect!)).to eq(WebMock.method(:disable_net_connect!))
+    end
   end
 
-  it "should alias disallow_net_connect! to disable_net_connect!" do
-    expect(WebMock.method(:disallow_net_connect!)).to eq(WebMock.method(:disable_net_connect!))
+  describe ".net_connect_allowed?" do
+    context 'enabled globally' do
+      before do
+        WebMock.enable_net_connect!
+      end
+
+      context 'without arguments' do
+        it 'returns WebMock::Config.instance.allow_net_connect' do
+          expect(WebMock.net_connect_allowed?).to eql(true)
+        end
+      end
+    end
+
+    context 'disabled with allowed remote string' do
+      before do
+        WebMock.disable_net_connect!(allow: "http://192.168.64.2:20031")
+      end
+
+      context 'without arguments' do
+        it 'returns WebMock::Config.instance.allow_net_connect' do
+          expect(WebMock.net_connect_allowed?).to eql(false)
+        end
+      end
+    end
+
+    context 'disabled globally' do
+      before do
+        WebMock.disable_net_connect!
+      end
+
+      context 'without arguments' do
+        it 'returns WebMock::Config.instance.allow_net_connect' do
+          expect(WebMock.net_connect_allowed?).to eql(false)
+        end
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: webmock
 version: !ruby/object:Gem::Version
-  version: 3.7.6
+  version: 3.9.0
 platform: ruby
 authors:
 - Bartosz Blimke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-29 00:00:00.000000000 Z
+date: 2020-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -407,9 +407,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/bblimke/webmock/issues
-  changelog_uri: https://github.com/bblimke/webmock/blob/v3.7.6/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/webmock/3.7.6
-  source_code_uri: https://github.com/bblimke/webmock/tree/v3.7.6
+  changelog_uri: https://github.com/bblimke/webmock/blob/v3.9.0/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/webmock/3.9.0
+  source_code_uri: https://github.com/bblimke/webmock/tree/v3.9.0
   wiki_uri: https://github.com/bblimke/webmock/wiki
 post_install_message: 
 rdoc_options: []
@@ -426,7 +426,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Library for stubbing HTTP requests in Ruby.