webmock 3.30.0 → 3.34.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0be0b6d1129e7014a36a5dbe7a7e77d3a25852d1668f54c455e0be96cd2d1287
-  data.tar.gz: db8c3267c3fbf2eef3b69f4b72764a82983e589a6508c9d0be8d2cd53047d484
+  metadata.gz: b66b694440da9739d8d23ccd8a260260739199235f076f4854387f7029c0c976
+  data.tar.gz: 96abe5bbe31e475bcec618aff66d43ac724b7cf15b08883ae864d62cac826e7c
 SHA512:
-  metadata.gz: ad6692051819395acd28a095acb54762b81b379b9d75115f0572351f2693973558978b24392f2086bb2dd6bb3969730881efb0d2dc54210440c9114bc2c867b6
-  data.tar.gz: d4c877e82c741f3319e66d803421eb0fb52f3d1a798465bc19c8b55e52d00fc57fca89cd5eb82a52f88d9f0223c2784adcb7110838405a42f05e9e5c26f53561
+  metadata.gz: 99395c27d7c6c270f37309e69da7f3688c43b8f158327d23b62b9829b3fff7a667280542017c71f18e2b822de6639394b2aeaa078aae7b7c67d7fd497363e918
+  data.tar.gz: 9378a048d2a03b1309eff3b5264ddca35e4f9268399a92e98147fa0e2d60e376d31ca2f1ccaca912f6d7ca859268b1d9ce173530e885c5055b99f3c2632bfd46

data/CHANGELOG.md

@@ -1,5 +1,115 @@
 # Changelog
 
+# 3.34.0
+
+* Allow `with(query: :any)` to match any query string (#1099)
+
+    `stub_request(:get, "www.example.com").with(query: :any)` matches requests with any query string, or none. RSpec's `anything` works the same way. Previously, this raised `NoMethodError`, and you had to write `with(query: hash_including({}))`.
+
+    Use a URL without query parameters when passing `query: :any`. Otherwise, WebMock raises `ArgumentError`.
+
+    Thanks to [nightpool](https://github.com/nightpool)
+
+* Raise a clear `ArgumentError` for an unsupported `query` option
+
+    Previously, a value such as `with(query: :all)` raised `NoMethodError` (undefined method `split`). The new error lists the supported values.
+
+* Show `anything` for keys given without a value to `hash_including` or `hash_excluding` outside RSpec
+
+    Previously, with Minitest or Test::Unit, messages showed `#<WebMock::Matchers::AnyArgMatcher:0x...>`, for example for `with(query: hash_including(:a))`. RSpec's own matchers already showed `anything`.
+
+* Provide `HTTP_HOST` to `to_rack` apps when the client has not supplied a Host header (#1084)
+
+    Previously, requests from some HTTP clients reached the Rack app without `HTTP_HOST`. This caused host checks such as Sinatra's `HostAuthorization` to see an empty host.
+
+    WebMock now fills in the host from the request URL, including the port when it is not the default. An explicit Host header is preserved.
+
+    Thanks to [Benoit Tigeot](https://github.com/benoittgt)
+
+* Fix Rack compatibility for `to_rack` apps
+
+    The request environment now passes `Rack::Lint`.
+
+    `SERVER_PORT` and `CONTENT_LENGTH` are now strings. If your app or tests read them directly, use string comparisons, such as `env['SERVER_PORT'] == "80"`. The environment also includes `SERVER_PROTOCOL`.
+
+    `CONTENT_TYPE` is omitted when the request has no content type. The `Content-Length` header is passed only as `CONTENT_LENGTH`, without an extra `HTTP_CONTENT_LENGTH` entry. `Transfer-Encoding` is removed because the body has already been decoded.
+
+    Repeated header values are joined into one string. Header values and the body read from `rack.input` now use binary (`ASCII-8BIT`) strings.
+
+# 3.33.0
+
+* Return `effective_url` as a String for stubbed Typhoeus responses (#869)
+
+    Previously, this was an `Addressable::URI`. If your code calls methods such as `effective_url.host`, parse the returned string into a URI first.
+
+    The URL keeps the request's port, query order and encoding. It follows curl's formatting: for example, `http://example.com:80` becomes `http://example.com:80/`. Stubbed timeouts now provide an `effective_url` too.
+
+    Thanks to [Tom Brammar](https://github.com/tbrammar)
+
+* Fix incorrect removal of default ports from displayed URLs
+
+    WebMock could accidentally remove `:80` or `:443` from a URL's path or query. For example, an error message could show `/foo/bar` instead of `/foo:80/bar`.
+
+    Only the host's default port is now removed. This also works when the port is immediately followed by a query string, as in `http://example.com:80?a=b`.
+
+* Set `return_code` to `:ok` for completed stubbed Typhoeus requests (#736)
+
+    `return_code` is now `:ok` and `return_message` is now `"No error"`; both were previously `nil`. This includes HTTP error responses such as 404: `:ok` means the transfer completed. Stubbed timeouts still return `:operation_timedout`.
+
+    Thanks to [Michael Spiz](https://github.com/spizm)
+
+* Fix the raw headers returned by stubbed Typhoeus responses
+
+    The `response_headers` string now uses the stubbed HTTP status. For example, a 404 stub no longer reports `HTTP/1.1 200 OK`.
+
+    Stubs without headers now return an empty `headers` hash (`{}`) instead of `nil`. Their `response_headers` contains the status line instead of being `nil`.
+
+    The raw headers use binary string encoding, matching real responses. For timeouts, `response_headers` is now an empty string.
+
+# 3.32.0
+
+* Make a `Net::HTTP` object created while WebMock was enabled behave like any other `Net::HTTP` object after `WebMock.disable!` (#1067)
+
+    Such an object, like a connection cached by net-http-persistent or by Capybara with Selenium, used to raise `ArgumentError` on `start` or a stubbed request, and `WebMock::NetConnectNotAllowedError` on any other request, after WebMock was disabled. It now sends real requests until WebMock is enabled again.
+
+    Thanks to [Mike Taylor](https://github.com/sealabcore) and [James Rodovich](https://github.com/rodovich)
+
+* Connect again when a request is retried on a `Net::HTTP` object that WebMock started without connecting and whose first real connection failed
+
+    Such a retry used to raise `NoMethodError` (undefined method `closed?` for nil). It now tries to connect again, and raises the connection error if that fails too.
+
+* Drop the `Transfer-Encoding` header from stubbed async-http responses, as WebMock already does with `Content-Length` (#1044)
+
+    A stub with a `Transfer-Encoding` header, such as `chunked`, used to fail with "Message contains both transfer encoding and content length". async-http sets both headers itself from the body, and its responses from real servers don't include them either.
+
+    Thanks to [Tim Mertens](https://github.com/tmertens)
+
+* Record requests made with curb's `http_patch` as PATCH requests with their body (#1112)
+
+    curb has `http_patch` since 1.0.8. WebMock recorded such a request as a GET, or as a POST after `post_body=`, so a PATCH stub never matched it.
+
+    Thanks to [Andy Williams](https://github.com/sobakasu)
+
+* Record a curb request sent without a body as having none, even after an earlier `http_post` or `http_patch` call with a body on the same `Curl::Easy` object
+
+    For example, after `c.http_post("a=1")`, `c.reset` and `c.http(:POST)`, the second request was recorded with the body `a=1`, so a stub for that body matched it.
+
+# 3.31.0
+
+* Return the contents of a `File` or `Pathname` body given to `to_return_json`, or returned by its body lambda, instead of encoding the object as a JSON string (#1119)
+
+    The file is read and closed as it is for `to_return`: when the stub is declared, or on each request when it comes from a lambda.
+
+    Thanks to [Alex](https://github.com/ac1982)
+
+* Match HTTP methods given as a string or in upper case, as in `stub_request("get", ...)`, `a_request("GET", ...)` or `assert_requested("post", ...)` (#821)
+
+    Before, such a method never matched, so the stub never applied and negative expectations like `assert_not_requested("get", ...)` always passed. A test that passed only because of this can now fail.
+
+    The method of a request is now always a lower case Symbol too. A request made with an upper case method, as Typhoeus does with `method: :POST`, now matches a `:post` stub, and callbacks and `with` blocks see `:post`.
+
+    Thanks to [Euisan Kim](https://github.com/euisan)
+
 # 3.30.0
 
 * Allow narrowing an RSpec expectation on a stub with `with`, as in `expect(stub).to have_been_requested.once.with(body: "abc")` (#1128)

data/README.md

@@ -299,6 +299,15 @@ Net::HTTP.get('www.example.com',
   '/thing/5.json?x=1&y=2&z=3&anyParam=4')    # ===> Success
 ```
 
+### Matching any query params
+
+```ruby
+stub_request(:get, "www.example.com").with(query: :any)
+
+RestClient.get("http://www.example.com/?q=example")    # ===> Success
+RestClient.get("http://www.example.com/")              # ===> Success
+```
+
 ### Matching query params using hash
 
 ```ruby
@@ -363,6 +372,20 @@ stub_request(:any, "www.example.com").
 Net::HTTP.get('www.example.com', '/') # ===> "{\"foo\": \"bar\"}"
 ```
 
+A `File` or `Pathname` body is returned as it is, so it should hold JSON that is already encoded:
+
+```ruby
+stub_request(:get, "www.example.com").
+  to_return_json(body: Pathname.new('spec/fixtures/response.json'))
+```
+
+As with `to_return`, the file is read and closed when the stub is declared, so later changes to it don't affect the response. To read the file on every request, return it from a lambda. A lambda that returns a `File` must open a new one each time, since each one is closed after it is read.
+
+```ruby
+stub_request(:get, "www.example.com").
+  to_return_json(body: -> { Pathname.new('spec/fixtures/response.json') })
+```
+
 ### Response with custom status message
 
 ```ruby

data/lib/webmock/http_lib_adapters/async_http_client_adapter.rb

@@ -207,6 +207,10 @@ if defined?(Async::HTTP)
       module WebMockApplication
         WEBMOCK_REQUEST_ID_HEADER = 'x-webmock-request-id'.freeze
 
+        # async-http sets these from the body itself. A stub's own values would
+        # conflict, as Transfer-Encoding does with the Content-Length it adds.
+        FRAMING_HEADERS = %w[content-length transfer-encoding].freeze
+
         class << self
           def call(request)
             request.read
@@ -233,8 +237,10 @@ if defined?(Async::HTTP)
 
           def build_response(webmock_response)
             headers = (webmock_response.headers || {}).each_with_object([]) do |(k, value), o|
+              next if FRAMING_HEADERS.include?(k.downcase)
+
               Array(value).each do |v|
-                o.push [k, v] unless k.downcase == 'content-length' # async-http appends the exact content-length automatically
+                o.push [k, v]
               end
             end
 

data/lib/webmock/http_lib_adapters/curb_adapter.rb

@@ -261,6 +261,15 @@ if defined?(Curl)
         end
       end
 
+      # curb has http_patch since 1.0.8.
+      if method_defined?(:http_patch)
+        def http_patch *data
+          @webmock_method = :patch
+          @post_body = data.join('&') unless data.empty?
+          super
+        end
+      end
+
       def http_put data = nil
         @webmock_method = :put
         @put_data = data if data
@@ -270,7 +279,7 @@ if defined?(Curl)
 
       def http_post *data
         @webmock_method = :post
-        @post_body = data.join('&') if data && !data.empty?
+        @post_body = data.join('&') unless data.empty?
         super
       end
       alias post http_post
@@ -280,6 +289,8 @@ if defined?(Curl)
         curb_or_webmock { super }
       ensure
         reset_webmock_method
+        # The body given to http_post or http_patch is for this request only.
+        @post_body = nil
       end
 
       def put_data= data

data/lib/webmock/http_lib_adapters/net_http.rb

@@ -15,7 +15,15 @@ module WebMock
       # This will be removed in Ruby 3.5. In Ruby 3.4, const_remove will warn.
       HAS_LEGACY_CONSTANT = Net.const_defined?(:HTTPSession)
 
+      # Objects created while WebMock was enabled are instances of WebMock's
+      # Net::HTTP class, so they check this to act like Net::HTTP once
+      # WebMock is disabled.
+      def self.enabled?
+        @enabled
+      end
+
       def self.enable!
+        @enabled = true
         Net.send(:remove_const, :HTTP)
         Net.send(:const_set, :HTTP, @webMockNetHTTP)
         if HAS_LEGACY_CONSTANT
@@ -25,6 +33,7 @@ module WebMock
       end
 
       def self.disable!
+        @enabled = false
         Net.send(:remove_const, :HTTP)
         Net.send(:const_set, :HTTP, OriginalNetHTTP)
         if HAS_LEGACY_CONSTANT
@@ -83,12 +92,20 @@ module WebMock
         end
 
         def request(request, body = nil, &block)
+          unless webmock_enabled?
+            # Reconnect for real if started with WebMock's stub socket.
+            ensure_actual_connection if started?
+            return super
+          end
+
           request_signature = WebMock::NetHTTPUtility.request_signature_from_request(self, request, body)
 
           WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
 
           if webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
-            @socket = Net::HTTP.socket_type.new
+            # Close the real connection left by an earlier request, if any.
+            @socket&.close
+            @socket = self.class.socket_type.new
             WebMock::CallbackRegistry.invoke_callbacks(
               {lib: :net_http}, request_signature, webmock_response)
             build_net_http_response(webmock_response, request.uri, &block)
@@ -125,23 +142,22 @@ module WebMock
           raise IOError, 'HTTP session already opened' if @started
           if block_given?
             begin
-              @socket = Net::HTTP.socket_type.new
+              @socket = self.class.socket_type.new
               @started = true
               return yield(self)
             ensure
               do_finish
             end
           end
-          @socket = Net::HTTP.socket_type.new
+          @socket = self.class.socket_type.new
           @started = true
           self
         end
 
-
         def ensure_actual_connection
           if @socket.is_a?(StubSocket)
-            @socket&.close
-            @socket = nil
+            # Keep the closed stub socket, so a failed connect is retried.
+            @socket.close
             do_start
           end
         end
@@ -149,6 +165,8 @@ module WebMock
         alias_method :start_with_connect, :start
 
         def start(&block)
+          return super unless webmock_enabled?
+
           uri = Addressable::URI.parse(WebMock::NetHTTPUtility.get_uri(self))
 
           if WebMock.net_http_connect_on_start?(uri)
@@ -205,6 +223,12 @@ module WebMock
             @@already_checked_for_right_http_connection = true
           end
         end
+
+        private
+
+        def webmock_enabled?
+          WebMock::HttpLibAdapters::NetHttpAdapter.enabled?
+        end
       end
       @webMockNetHTTP.version_1_2
       [

data/lib/webmock/http_lib_adapters/typhoeus_hydra_adapter.rb

@@ -52,8 +52,8 @@ if defined?(Typhoeus)
           Typhoeus.on_complete.delete_if {|v| v == AFTER_REQUEST_CALLBACK }
         end
 
-        def self.build_request_signature(req)
-          uri = WebMock::Util::URI.heuristic_parse(req.url)
+        def self.build_request_signature(req, url = req.url)
+          uri = WebMock::Util::URI.heuristic_parse(url)
           uri.path = uri.normalized_path.gsub("[^:]//","/")
 
           headers = req.options[:headers]
@@ -89,42 +89,69 @@ if defined?(Typhoeus)
           webmock_response
         end
 
-        def self.generate_typhoeus_response(request_signature, webmock_response)
-          response = if webmock_response.should_timeout
-            ::Typhoeus::Response.new(
+        def self.generate_typhoeus_response(webmock_response, url)
+          response_options = if webmock_response.should_timeout
+            {
               code: 0,
               status_message: "",
               body: "",
               headers: {},
               return_code: :operation_timedout,
-              total_time: 0.0,
-              starttransfer_time: 0.0,
-              appconnect_time: 0.0,
-              pretransfer_time: 0.0,
-              connect_time: 0.0,
-              namelookup_time: 0.0,
-              redirect_time: 0.0
-            )
+              response_headers: ""
+            }
           else
-            ::Typhoeus::Response.new(
+            {
               code: webmock_response.status[0],
               status_message: webmock_response.status[1],
               body: webmock_response.body,
               headers: webmock_response.headers,
-              effective_url: request_signature.uri,
-              total_time: 0.0,
-              starttransfer_time: 0.0,
-              appconnect_time: 0.0,
-              pretransfer_time: 0.0,
-              connect_time: 0.0,
-              namelookup_time: 0.0,
-              redirect_time: 0.0
-            )
+              return_code: :ok,
+              response_headers: response_headers_string(webmock_response)
+            }
           end
+          response = ::Typhoeus::Response.new(response_options.merge(
+            effective_url: effective_url(url),
+            total_time: 0.0,
+            starttransfer_time: 0.0,
+            appconnect_time: 0.0,
+            pretransfer_time: 0.0,
+            connect_time: 0.0,
+            namelookup_time: 0.0,
+            redirect_time: 0.0
+          ))
           response.mock = :webmock
           response
         end
 
+        # Without response_headers, Typhoeus builds them for a mocked response
+        # from its return_code, as in "HTTP/1.1 ok Mock Reason Phrase".
+        def self.response_headers_string(webmock_response)
+          code, reason = webmock_response.status
+          lines = ["HTTP/1.1 #{code} #{reason}"]
+          (webmock_response.headers || {}).each do |name, values|
+            Array(values).each { |value| lines << "#{name}: #{value}" }
+          end
+          # Bytes, as in a real response, so values in different encodings join.
+          lines.map(&:b).join("\r\n") + "\r\n\r\n"
+        end
+
+        # The request URL as curl reports it: with its port, query and encoding as
+        # given, but with a lower case scheme, http:// when there is none, dot
+        # segments resolved, "/" for an empty path and no empty query or
+        # fragment. Like curl's, it is a binary string.
+        def self.effective_url(url)
+          # A scheme needs at least one slash after it, so localhost:3000 has
+          # none. heuristic_parse turns http:/ and http:/// into http://.
+          url = "http://#{url}" unless url.match?(%r{\A[a-z][a-z0-9+.\-]*:/}i)
+          uri = WebMock::Util::URI.heuristic_parse(url)
+          uri.scheme = uri.scheme.downcase
+          uri.path = Addressable::URI.normalize_path(uri.path)
+          uri.path = "/" if uri.path.empty?
+          uri.query = nil if uri.query == ""
+          uri.fragment = nil if uri.fragment == ""
+          uri.to_s.b
+        end
+
         def self.request_hash(request_signature)
           hash = {}
 
@@ -160,14 +187,15 @@ if defined?(Typhoeus)
           res = true
 
           unless WebMock::HttpLibAdapters::TyphoeusAdapter.disabled?
-            request_signature = ::WebMock::HttpLibAdapters::TyphoeusAdapter.build_request_signature(request)
+            # Typhoeus builds a curl handle to work out the URL, so do it once.
+            url = request.url
+            request_signature = ::WebMock::HttpLibAdapters::TyphoeusAdapter.build_request_signature(request, url)
             request.block_connection = false;
 
             ::WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
 
             if webmock_response = ::WebMock::StubRegistry.instance.response_for_request(request_signature)
-              # ::WebMock::HttpLibAdapters::TyphoeusAdapter.stub_typhoeus(request_signature, webmock_response, self)
-              response = ::WebMock::HttpLibAdapters::TyphoeusAdapter.generate_typhoeus_response(request_signature, webmock_response)
+              response = ::WebMock::HttpLibAdapters::TyphoeusAdapter.generate_typhoeus_response(webmock_response, url)
               if request.respond_to?(:on_headers)
                 request.execute_headers_callbacks(response)
               end

data/lib/webmock/matchers/any_arg_matcher.rb

@@ -10,6 +10,10 @@ module WebMock
       def ==(other)
         true
       end
+
+      def inspect
+        "anything"
+      end
     end
   end
 end

data/lib/webmock/rack_response.rb

@@ -27,37 +27,56 @@ module WebMock
 
     def build_rack_env(request)
       uri = request.uri
+      port = uri.inferred_port
       headers = (request.headers || {}).dup
-      body = request.body || ''
+      body = (request.body || '').b
+      content_type = headers.delete('Content-Type')
+      headers.delete('Content-Length')
+      # The body is already decoded, as a server passes it on.
+      headers.delete('Transfer-Encoding')
 
       env = {
         # CGI variables specified by Rack
-        'REQUEST_METHOD' => request.method.to_s.upcase,
-        'CONTENT_TYPE'   => headers.delete('Content-Type'),
-        'CONTENT_LENGTH' => body.bytesize,
-        'PATH_INFO'      => uri.path,
-        'QUERY_STRING'   => uri.query || '',
-        'SERVER_NAME'    => uri.host,
-        'SERVER_PORT'    => uri.port,
-        'SCRIPT_NAME'    => ""
+        'REQUEST_METHOD'  => request.method.to_s.upcase,
+        'CONTENT_LENGTH'  => body.bytesize.to_s,
+        'PATH_INFO'       => uri.path,
+        'QUERY_STRING'    => uri.query || '',
+        'SERVER_NAME'     => uri.host,
+        'SERVER_PORT'     => port.to_s,
+        'SERVER_PROTOCOL' => 'HTTP/1.1',
+        'SCRIPT_NAME'     => ""
       }
+      env['CONTENT_TYPE'] = header_value('Content-Type', content_type) if content_type
 
       env['HTTP_AUTHORIZATION'] = 'Basic ' + [uri.userinfo].pack('m').delete("\r\n") if uri.userinfo
 
       # Rack-specific variables
       env['rack.input']      = StringIO.new(body)
       env['rack.errors']     = $stderr
-      if !Rack.const_defined?(:RELEASE) || Rack::RELEASE < "3"
-        env['rack.version']    = Rack::VERSION
+      if !Rack.const_defined?(:RELEASE) || Gem::Version.new(Rack::RELEASE) < Gem::Version.new("3")
+        env['rack.version']      = Rack::VERSION
+        env['rack.multithread']  = false
+        env['rack.multiprocess'] = false
       end
       env['rack.url_scheme'] = uri.scheme
       env['rack.run_once']   = true
 
       headers.each do |k, v|
-        env["HTTP_#{k.tr('-','_').upcase}"] = v
+        env["HTTP_#{k.tr('-','_').upcase}"] = header_value(k, v)
       end
 
+      # Many clients add Host only when sending, so fill it in as they would.
+      env['HTTP_HOST'] ||= port == uri.default_port ? uri.host : "#{uri.host}:#{port}"
+
       env
     end
+
+    private
+
+    # Like a server, pass header values as bytes and join repeated ones. Rack
+    # splits cookies on "; ", so join those that way.
+    def header_value(name, value)
+      Array(value).map { |v| v.to_s.b }.join(name == 'Cookie' ? '; ' : WebMock::Util::Headers::JOIN)
+    end
   end
 end

data/lib/webmock/request_pattern.rb

@@ -10,6 +10,10 @@ module WebMock
     def rSpecHashExcludingMatcher?(matcher)
       matcher.class.name =~ /R?Spec::Mocks::ArgumentMatchers::HashExcludingMatcher/
     end
+
+    def rSpecAnyArgMatcher?(matcher)
+      matcher.class.name =~ /R?Spec::Mocks::ArgumentMatchers::AnyArgMatcher/
+    end
   end
 
   class RequestPattern
@@ -94,8 +98,11 @@ module WebMock
 
 
   class MethodPattern
+    # Request signatures store the method as a lower case Symbol, so a method
+    # given as a String or in upper case, like "get" or :GET, matches too.
+    # Anything else, such as nil, is kept as given and never matches.
     def initialize(pattern)
-      @pattern = pattern
+      @pattern = pattern.respond_to?(:to_sym) ? pattern.to_sym.downcase : pattern
     end
 
     def matches?(method)
@@ -126,6 +133,10 @@ module WebMock
     def add_query_params(query_params)
       @query_params = if query_params.is_a?(Hash)
         query_params
+      elsif query_params.equal?(:any) \
+              || query_params.is_a?(WebMock::Matchers::AnyArgMatcher) \
+              || rSpecAnyArgMatcher?(query_params)
+        WebMock::Matchers::AnyArgMatcher.new(nil)
       elsif query_params.is_a?(WebMock::Matchers::HashIncludingMatcher) \
               || query_params.is_a?(WebMock::Matchers::HashExcludingMatcher)
         query_params
@@ -133,8 +144,10 @@ module WebMock
         WebMock::Matchers::HashIncludingMatcher.from_rspec_matcher(query_params)
       elsif rSpecHashExcludingMatcher?(query_params)
         WebMock::Matchers::HashExcludingMatcher.from_rspec_matcher(query_params)
-      else
+      elsif query_params.nil? || query_params.is_a?(String)
         WebMock::Util::QueryMapper.query_to_values(query_params, notation: Config.instance.query_values_notation)
+      else
+        raise ArgumentError, "Query should be a String, Hash, :any, nil, or a hash_including or hash_excluding matcher. Got: #{query_params.class}"
       end
     end
 
@@ -150,6 +163,10 @@ module WebMock
 
     private
 
+    def raise_any_query_with_uri_query
+      raise ArgumentError, "query: :any can't be combined with a query in the URI #{pattern_inspect}, because no request would match. Remove the query from the URI."
+    end
+
     def pattern_inspect
       @pattern.inspect
     end
@@ -177,12 +194,17 @@ module WebMock
 
   class URIAddressablePattern  < URIPattern
     def add_query_params(query_params)
+      super(query_params)
+      # With query params, the template is matched against the URI without its
+      # query, so a literal query in the template can never match.
+      if @query_params.is_a?(WebMock::Matchers::AnyArgMatcher) && @pattern.pattern.gsub(/\{[^}]*\}/, '').include?('?')
+        raise_any_query_with_uri_query
+      end
       @@add_query_params_warned ||= false
       if not @@add_query_params_warned
         @@add_query_params_warned = true
         warn "WebMock warning: ignoring query params in RFC 6570 template and checking them with WebMock"
       end
-      super(query_params)
     end
 
     private
@@ -227,6 +249,9 @@ module WebMock
         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
+      elsif @query_params.is_a?(WebMock::Matchers::AnyArgMatcher) && @pattern.query
+        # The URI is then compared without its query, so it could never match.
+        raise_any_query_with_uri_query
       end
     end
 

data/lib/webmock/request_signature.rb

@@ -4,11 +4,11 @@ module WebMock
 
   class RequestSignature
 
-    attr_accessor :method, :uri, :body
-    attr_reader :headers
+    attr_accessor :uri, :body
+    attr_reader :method, :headers
 
     def initialize(method, uri, options = {})
-      self.method = method.to_sym
+      self.method = method
       self.uri = uri.is_a?(Addressable::URI) ? uri : WebMock::Util::URI.normalize_uri(uri)
       assign_options(options)
     end
@@ -23,6 +23,10 @@ module WebMock
       string
     end
 
+    def method=(method)
+      @method = method.to_sym.downcase
+    end
+
     def headers=(headers)
       @headers = WebMock::Util::Headers.normalize_headers(headers)
     end

data/lib/webmock/request_stub.rb

@@ -39,13 +39,10 @@ module WebMock
             else
               body.call
             end
-            b = b.to_json unless b.is_a?(String)
-            b
+            json_response_body(b)
           }
-        elsif !body.is_a?(String)
-          body.to_json
         else
-          body
+          json_response_body(body)
         end
 
         resp_h.merge(
@@ -130,5 +127,16 @@ module WebMock
       end
       stub
     end
+
+    private
+
+    def json_response_body(body)
+      case body
+      when String, IO, Pathname
+        body
+      else
+        body.to_json
+      end
+    end
   end
 end

data/lib/webmock/util/uri.rb

@@ -58,8 +58,8 @@ module WebMock
 
       def self.strip_default_port_from_uri_string(uri_string)
         case uri_string
-        when %r{^http://}  then uri_string.sub(%r{:80(/|$)}, '\1')
-        when %r{^https://} then uri_string.sub(%r{:443(/|$)}, '\1')
+        when %r{^http://}  then uri_string.sub(%r{\A(http://[^/?#]+):80(?=[/?#]|\z)}, '\1')
+        when %r{^https://} then uri_string.sub(%r{\A(https://[^/?#]+):443(?=[/?#]|\z)}, '\1')
         else uri_string
         end
       end

data/lib/webmock/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module WebMock
-  VERSION = '3.30.0' unless defined?(::WebMock::VERSION)
+  VERSION = '3.34.0' unless defined?(::WebMock::VERSION)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: webmock
 version: !ruby/object:Gem::Version
-  version: 3.30.0
+  version: 3.34.0
 platform: ruby
 authors:
 - Bartosz Blimke
@@ -360,9 +360,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/bblimke/webmock/issues
-  changelog_uri: https://github.com/bblimke/webmock/blob/v3.30.0/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/webmock/3.30.0
-  source_code_uri: https://github.com/bblimke/webmock/tree/v3.30.0
+  changelog_uri: https://github.com/bblimke/webmock/blob/v3.34.0/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/webmock/3.34.0
+  source_code_uri: https://github.com/bblimke/webmock/tree/v3.34.0
   wiki_uri: https://github.com/bblimke/webmock/wiki
 rdoc_options: []
 require_paths: