webmock 3.8.2 → 3.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e810298e20d5299b4db93de105d6bfd2928db868ed70d6113e1e308091130f7c
-  data.tar.gz: d35d0053907cb949df0a891e9b9e6e4f2c62143651fc2b19a2d02192fb1d6f91
+  metadata.gz: 0a87447f51d9795b044f000997ec83ce2d5673373a7a06dec331fa2de9d008bf
+  data.tar.gz: 5122a5da6a3914b138f1f1e1e690d82f1634f92af63da7efe4e1ac94f48ab4bf
 SHA512:
-  metadata.gz: f42ea1b65f3203df24d0dc5cf39204274c30339eb8831bc95570da25cc497cb51bb9cc696636a437b941aea050940574d01c6632dbe9db29bd67f67eab2e15d9
-  data.tar.gz: 902b36dd0712ecafe4e26eca7416e6444638ea2687a86b434382428a6158c6b7a9155b17b62c30755712cc5cf51985482b6d7c386461d11ed5ade0afa069b45c
+  metadata.gz: 8af4021d6ab4e24f09a1bccebc87c2031067c78dfadf92b3a598df0eb56742c3eed1dae935bec0abcd892082933c14114e964a95d41369d9855f7417f3d6b149
+  data.tar.gz: 68f43e43910e6bce66eb847caca053fd94bf3fe363d838deb6e31e98b83d9013592a03d0df499f059b5473d4ad81401e6720e86ae9799a19e62f182d41ea24b0

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.3
+
+  * Make httpclient_adapter thread-safe
+
+    Thanks to [Adam Harwood](https://github.com/adam-harwood)
+
+# 3.9.2
+
+  * Made global stubs thread-safe
+
+    Thanks to [Adam Harwood](https://github.com/adam-harwood)
+
+# 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

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
@@ -1120,6 +1129,15 @@ People who submitted patches and new features or suggested improvements. Many th
 * Samuel Williams
 * Patrik Ragnarsson
 * Alex Coomans
+* Vesa Laakso
+* John Hawthorn
+* guppy0356
+* Thilo Rusche
+* Andrew Stuntz
+* Lucas Uyezu
+* Bruno Sutic
+* Ryan Kerr
+* Adam Harwood
 
 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/httpclient_adapter.rb

@@ -43,6 +43,9 @@ if defined?(::HTTPClient)
   end
 
   module WebMockHTTPClients
+
+    REQUEST_RESPONSE_LOCK = Mutex.new
+
     def do_get_block(req, proxy, conn, &block)
       do_get(req, proxy, conn, false, &block)
     end
@@ -57,7 +60,7 @@ if defined?(::HTTPClient)
       WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
 
       if webmock_responses[request_signature]
-        webmock_response = webmock_responses.delete(request_signature)
+        webmock_response = synchronize_request_response { webmock_responses.delete(request_signature) }
         response = build_httpclient_response(webmock_response, stream, req.header, &block)
         @request_filter.each do |filter|
           filter.filter_response(req, response)
@@ -68,7 +71,7 @@ if defined?(::HTTPClient)
         res
       elsif WebMock.net_connect_allowed?(request_signature.uri)
         # in case there is a nil entry in the hash...
-        webmock_responses.delete(request_signature)
+        synchronize_request_response { webmock_responses.delete(request_signature) }
 
         res = if stream
           do_get_stream_without_webmock(req, proxy, conn, &block)
@@ -100,7 +103,7 @@ if defined?(::HTTPClient)
     def do_request_async(method, uri, query, body, extheader)
       req = create_request(method, uri, query, body, extheader)
       request_signature = build_request_signature(req)
-      webmock_request_signatures << request_signature
+      synchronize_request_response { webmock_request_signatures << request_signature }
 
       if webmock_responses[request_signature] || WebMock.net_connect_allowed?(request_signature.uri)
         super
@@ -184,7 +187,9 @@ if defined?(::HTTPClient)
 
     def webmock_responses
       @webmock_responses ||= Hash.new do |hash, request_signature|
-        hash[request_signature] = WebMock::StubRegistry.instance.response_for_request(request_signature)
+        synchronize_request_response do
+          hash[request_signature] = WebMock::StubRegistry.instance.response_for_request(request_signature)
+        end
       end
     end
 
@@ -193,8 +198,10 @@ if defined?(::HTTPClient)
     end
 
     def previous_signature_for(signature)
-      return nil unless index = webmock_request_signatures.index(signature)
-      webmock_request_signatures.delete_at(index)
+      synchronize_request_response do
+        return nil unless index = webmock_request_signatures.index(signature)
+        webmock_request_signatures.delete_at(index)
+      end
     end
 
     private
@@ -209,6 +216,16 @@ if defined?(::HTTPClient)
         hdrs
       end
     end
+
+    def synchronize_request_response
+      if REQUEST_RESPONSE_LOCK.owned?
+        yield
+      else
+        REQUEST_RESPONSE_LOCK.synchronize do
+          yield
+        end
+      end
+    end
   end
 
   class WebMockHTTPClient < HTTPClient

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

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

@@ -23,10 +23,20 @@ module WebMock
       # That way, there's no race condition in case #to_return
       # doesn't run immediately after stub.with.
       responses = {}
-
-      stub = ::WebMock::RequestStub.new(:any, /.*/).with { |request|
-        responses[request.object_id] = yield(request)
-      }.to_return(lambda { |request| responses.delete(request.object_id) })
+      response_lock = Mutex.new
+
+      stub = ::WebMock::RequestStub.new(:any, ->(uri) { true }).with { |request|
+        update_response = -> { responses[request.object_id] = yield(request) }
+
+        # The block can recurse, so only lock if we don't already own it
+        if response_lock.owned?
+          update_response.call
+        else
+          response_lock.synchronize(&update_response)
+        end
+      }.to_return(lambda { |request|
+        response_lock.synchronize { responses.delete(request.object_id) }
+      })
 
       global_stubs.push stub
     end

data/lib/webmock/version.rb

@@ -1,3 +1,3 @@
 module WebMock
-  VERSION = '3.8.2' unless defined?(::WebMock::VERSION)
+  VERSION = '3.9.3' 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/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.2
+  version: 3.9.3
 platform: ruby
 authors:
 - Bartosz Blimke
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-02-12 00:00:00.000000000 Z
+date: 2020-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -407,11 +407,11 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/bblimke/webmock/issues
-  changelog_uri: https://github.com/bblimke/webmock/blob/v3.8.2/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/webmock/3.8.2
-  source_code_uri: https://github.com/bblimke/webmock/tree/v3.8.2
+  changelog_uri: https://github.com/bblimke/webmock/blob/v3.9.3/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/webmock/3.9.3
+  source_code_uri: https://github.com/bblimke/webmock/tree/v3.9.3
   wiki_uri: https://github.com/bblimke/webmock/wiki
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -427,7 +427,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Library for stubbing HTTP requests in Ruby.
 test_files: