webmock 3.8.0 → 3.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7f69433e4cc2a3e16c2ba55df62db7f99585200c9bc9bc1d1e9f53df9fc8bb6
-  data.tar.gz: ffa4936d1432c8256bcd244db949cd75342170d60c9920707846ae6d12540434
+  metadata.gz: 57c2c81fa3eb74334f703d9f92eb11cea8b06f1c70b713fdee1a071a90e99744
+  data.tar.gz: 96798ebd031599d59d06ff8d2457af877ba6d4a7e9d20ef9e464396c9104bc2c
 SHA512:
-  metadata.gz: 272c6a7bab37739d29fe8412264227325c4ceda06d17a6df13ba6ed317bda6770865063ef99b215c7880029f4a4dca1114e88fb5c0c017efeddee3a67f68cdf9
-  data.tar.gz: b86032f68e0e058d99c2ab61b1d360756d9bf4611cf383588feaad866a1d33964b4150a7819f5c1b0c64651539aed99499de7f8e1efbac476f99769f76abcfd4
+  metadata.gz: d6f0e72a1ecc925a006b9f781cb2e873a8dcafef0a6b80be74df2ad34bdb3eba0a9d02571f72fa825321da86d2a0afdbbdfb4b56e7c3b280bc1643b2acd76100
+  data.tar.gz: 123fdca940fe7ea90b015cb6b085a063a00becef933df84335d1cf762780c12066590ab943c4cd5eba91bba4603f3663d4e8532ca374c036f5c0f306de03e28f

data/.travis.yml

@@ -1,19 +1,24 @@
 before_install:
   - gem update --system -N
 rvm:
-  - 2.3.8
-  - 2.4.6
   - 2.5.5
   - 2.6.3
   - 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,65 @@
 # Changelog
 
+# 3.9.1
+
+  Fixed support for passing `URI` objects as second argument of `stub_request`
+
+    Thanks to [Ryan Kerr](https://github.com/leboshi)
+
+## 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

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
@@ -1118,6 +1127,16 @@ People who submitted patches and new features or suggested improvements. Many th
 * Ryan Davis
 * Brandur
 * Samuel Williams
+* Patrik Ragnarsson
+* Alex Coomans
+* Vesa Laakso
+* John Hawthorn
+* guppy0356
+* Thilo Rusche
+* Andrew Stuntz
+* Lucas Uyezu
+* Bruno Sutic
+* Ryan Kerr
 
 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

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

@@ -252,6 +252,13 @@ 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
@@ -279,19 +286,22 @@ module Net  #:nodoc: all
     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
@@ -107,11 +109,13 @@ module WebMock
     include RSpecMatcherDetector
 
     def initialize(pattern)
-      @pattern = case pattern
-      when Addressable::URI, Addressable::Template
+      @pattern = if pattern.is_a?(Addressable::URI) \
+                    || pattern.is_a?(Addressable::Template)
+        pattern
+      elsif pattern.respond_to?(:call)
         pattern
       else
-          WebMock::Util::URI.normalize_uri(pattern)
+        WebMock::Util::URI.normalize_uri(pattern)
       end
       @query_params = nil
     end
@@ -131,38 +135,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 +182,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 +241,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.8.0' unless defined?(::WebMock::VERSION)
+  VERSION = '3.9.1' 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,21 @@ describe WebMock::RequestPattern do
         to match(WebMock::RequestSignature.new(:get, "www.example.com"))
     end
 
+    it "should match if uri matches requesst uri as URI object" do
+      expect(WebMock::RequestPattern.new(:get, URI.parse("www.example.com"))).
+        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 +147,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"))
@@ -199,7 +238,7 @@ describe WebMock::RequestPattern do
             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
+        it "should not match request query params if params don't match" do
           expect(WebMock::RequestPattern.new(:get, /.*example.*/, query: {"x" => ["b", "c"]})).
             not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
         end
@@ -229,13 +268,85 @@ describe WebMock::RequestPattern do
         end
       end
 
+      describe "when uri is described as URI" do
+        it "should match request query params" do
+          expect(WebMock::RequestPattern.new(:get, URI.parse("www.example.com"), query: {"a" => ["b", "c"]})).
+            to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
+        end
+
+        it "should not match request query params if params don't match" do
+          expect(WebMock::RequestPattern.new(:get, URI.parse("www.example.com"), 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.parse("www.example.com"),
+          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.parse("www.example.com"),
+          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.parse("www.example.com"),
+          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.parse("www.example.com"),
+          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 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 not 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"]})).
             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
+        it "should not match request query params if params don't match" do
           expect(WebMock::RequestPattern.new(:get, Addressable::Template.new("www.example.com"), query: {"x" => ["b", "c"]})).
             not_to match(WebMock::RequestSignature.new(:get, "www.example.com?a[]=b&a[]=c"))
         end

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.8.0
+  version: 3.9.1
 platform: ruby
 authors:
 - Bartosz Blimke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-14 00:00:00.000000000 Z
+date: 2020-09-14 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.8.0/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/webmock/3.8.0
-  source_code_uri: https://github.com/bblimke/webmock/tree/v3.8.0
+  changelog_uri: https://github.com/bblimke/webmock/blob/v3.9.1/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/webmock/3.9.1
+  source_code_uri: https://github.com/bblimke/webmock/tree/v3.9.1
   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.