webmock 3.29.0 → 3.34.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd5a0e377558900faf49baabeca47478c71196acd38c625b30ed13d48cb3945a
-  data.tar.gz: 7956de226b2fa9ad8f692319e6ea5ea4ca666c77c48488feb58470e79474ce26
+  metadata.gz: b66b694440da9739d8d23ccd8a260260739199235f076f4854387f7029c0c976
+  data.tar.gz: 96abe5bbe31e475bcec618aff66d43ac724b7cf15b08883ae864d62cac826e7c
 SHA512:
-  metadata.gz: dd9d32d168c7a3e3719b467c519393158cf1b279213acc1e515ac0ff1f88f4f60bc4831e975eae23d18b2fb0d08c84390b180ce52f68a492852d1981dfa5e29d
-  data.tar.gz: e4bb8d187695bde02c1bcadd89923b24d26e2174676f094ac93cc551e5e5688b242ee519c565151ad7423162557d47ee86bb97c981529134ae4bebfccbd4d5d2
+  metadata.gz: 99395c27d7c6c270f37309e69da7f3688c43b8f158327d23b62b9829b3fff7a667280542017c71f18e2b822de6639394b2aeaa078aae7b7c67d7fd497363e918
+  data.tar.gz: 9378a048d2a03b1309eff3b5264ddca35e4f9268399a92e98147fa0e2d60e376d31ca2f1ccaca912f6d7ca859268b1d9ce173530e885c5055b99f3c2632bfd46

data/CHANGELOG.md

@@ -1,5 +1,131 @@
 # 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)
+
+    The expectation counts only the requests that match both the stub and the conditions given to `with`. The stub itself does not change.
+
+    Thanks to [Sébastien S.](https://github.com/inkstak)
+
+* Show the JSON body hint for expectations narrowed with `with` too, and no longer show it when a block is given to the stub or expectation, since checking would mean calling the block
+
+* Allow a full URL with a path in `disable_net_connect!(allow: ...)`, as in `allow: "https://github.com/mozilla/geckodriver/releases/latest"` (#977)
+
+    URLs are compared the same way as in stubs, so the default port, letter case in the host, and the order and encoding of query parameters don't matter. A URL without a path or query allows every path on that scheme, host and port; a trailing slash restricts requests to `/` with no query string. Credentials in either URL are ignored.
+
+    Thanks to [Henry Blyth](https://github.com/henrahmagix)
+
 # 3.29.0
 
 * Show a body diff for JSON requests whose content type has a `+json` suffix, such as `application/vnd.api+json`, and for the other content types WebMock already matches as JSON (#734)

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
@@ -573,6 +596,21 @@ RestClient.get('www.example.org', '/')      # ===> Failure
 RestClient.get('www.example.org:8080', '/') # ===> Allowed
 ```
 
+With a `String` specifying a full URL:
+
+```ruby
+WebMock.disable_net_connect!(allow: 'https://www.example.org/health')
+
+RestClient.get('https://www.example.org/health')        # ===> Allowed
+RestClient.get('https://www.example.org/health?full=1') # ===> Failure
+RestClient.get('https://www.example.org/health/db')     # ===> Failure
+RestClient.get('https://www.example.org/')              # ===> Failure
+```
+
+A URL with a path allows only that path and query string. URLs are compared the same way as in stubs, so the default port, letter case in the host, and the order and encoding of query parameters don't matter.
+
+A URL without a path or query, such as `https://www.example.org`, allows every path on that scheme, host and port. Adding the trailing slash (`https://www.example.org/`) allows only the root path `/` with no query string. To allow every path under a prefix, use a `Regexp`.
+
 With a `Regexp` matching the URI:
 
 ```ruby
@@ -637,6 +675,8 @@ This forces WebMock Net::HTTP adapter to always connect on `Net::HTTP.start`. At
 WebMock.allow_net_connect!(net_http_connect_on_start: "www.example.com")
 ```
 
+The path is not known when the connection is made, so a URL with a path given here never matches.
+
 ## Setting Expectations
 
 ### Setting expectations in Test::Unit
@@ -751,11 +791,17 @@ expect(a_request(:post, "www.example.com").
 ### Setting expectations in RSpec on the stub
 
 ```ruby
-stub = stub_request(:get, "www.example.com")
+stub = stub_request(:post, "www.example.com")
+
 # ... make requests ...
-expect(stub).to have_been_requested
+
+expect(stub).to have_been_requested.twice
+expect(stub).to have_been_requested.once.with(body: {"a" => [1, 2, 3]})
+expect(stub).to have_been_requested.once.with(body: {"a" => [4, 5, 6]})
 ```
 
+Options and a block given to `with` take the same form as in `stub_request(...).with`. The expectation then counts only the requests that match both the stub and those conditions. The stub itself does not change.
+
 ## Clearing stubs and request history
 
 If you want to reset all current stubs and history of requests use `WebMock.reset!`

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/json_body_hint.rb

@@ -17,24 +17,48 @@ module WebMock
     EXPECTATION_HINT = "Hint: a request was made with the same JSON body as expected, " \
                        "but formatted differently, for example with keys in another order. #{ADVICE}"
 
-    # True when the pattern declares its body as a JSON object or array string,
-    # the request has a JSON content type and a body that parses to the same
-    # JSON but is written differently, and the pattern's method, URI and headers
-    # match the request. A block given to the pattern is not called.
+    # True when one of the patterns declares its body as a JSON object or array
+    # string, the request has a JSON content type and a body that parses to the
+    # same JSON but is written differently, and the method, URI and headers of
+    # every pattern match the request. Any other patterns the request has to
+    # match, such as the conditions of an RSpec expectation, must not declare
+    # a body of their own.
+    #
+    # Building a failure message must not call a block given to with, which
+    # could raise and replace the failure, or repeat side effects. So there is
+    # no hint when any of the patterns has one.
+    #
+    # The body is checked first, since that runs no user code, so URI and
+    # header matchers are only evaluated when a hint is otherwise possible.
     def self.applies?(request_pattern, request_signature)
-      return false unless request_pattern.is_a?(RequestPattern) && request_pattern.body_pattern
+      patterns = parts_of(request_pattern)
+      return false unless patterns.all? { |pattern| pattern.is_a?(RequestPattern) && pattern.with_block.nil? }
 
-      expected = request_pattern.body_pattern.pattern
+      with_body = patterns.select(&:body_pattern)
+      return false unless with_body.size == 1
+      return false unless body_differs_only_in_formatting?(with_body.first.body_pattern, request_signature)
+
+      patterns.all? { |pattern| matches_except_body?(pattern, request_signature) }
+    end
+
+    # A pattern made of parts that must all match, such as an RSpec expectation
+    # with conditions, responds to #patterns. A stub stands for its pattern.
+    def self.parts_of(request_pattern)
+      parts = request_pattern.respond_to?(:patterns) ? request_pattern.patterns : [request_pattern]
+      parts.map { |part| part.is_a?(RequestStub) ? part.request_pattern : part }
+    end
+
+    def self.body_differs_only_in_formatting?(body_pattern, request_signature)
+      expected = body_pattern.pattern
       actual = request_signature.body
       return false unless expected.is_a?(String) && actual.is_a?(String) && expected != actual
       return false unless request_signature.json_headers?
 
       expected_json = parse_json(expected)
       return false unless expected_json.is_a?(Hash) || expected_json.is_a?(Array)
-      # eql? compares nested values strictly, so 1 and 1.0 are different.
-      return false unless expected_json.eql?(parse_json(actual))
 
-      matches_except_body?(request_pattern, request_signature)
+      # eql? compares nested values strictly, so 1 and 1.0 are different.
+      expected_json.eql?(parse_json(actual))
     end
 
     def self.matches_except_body?(request_pattern, request_signature)
@@ -48,6 +72,6 @@ module WebMock
     rescue ::JSON::JSONError, EncodingError
       nil
     end
-    private_class_method :matches_except_body?, :parse_json
+    private_class_method :parts_of, :body_differs_only_in_formatting?, :matches_except_body?, :parse_json
   end
 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,11 +10,15 @@ 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
 
-    attr_reader :method_pattern, :uri_pattern, :body_pattern, :headers_pattern
+    attr_reader :method_pattern, :uri_pattern, :body_pattern, :headers_pattern, :with_block
 
     def initialize(method, uri, options = {})
       @method_pattern  = MethodPattern.new(method)
@@ -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/rspec/matchers/request_pattern_matcher.rb

@@ -52,13 +52,22 @@ module WebMock
       self
     end
 
+    # Counts only the requests that also match the given conditions, which
+    # take the same options and block as RequestPattern#with. Like
+    # RequestPattern#with, calling it again adds to the conditions. The stub
+    # or request pattern under test is not changed.
+    def with(options = {}, &block)
+      (@conditions ||= RequestPattern.new(:any, ANY_URI)).with(options, &block)
+      self
+    end
+
     def matches?(request_pattern)
-      @request_execution_verifier.request_pattern = request_pattern
+      @request_execution_verifier.request_pattern = with_conditions(request_pattern)
       @request_execution_verifier.matches?
     end
 
     def does_not_match?(request_pattern)
-      @request_execution_verifier.request_pattern = request_pattern
+      @request_execution_verifier.request_pattern = with_conditions(request_pattern)
       @request_execution_verifier.does_not_match?
     end
 
@@ -76,5 +85,41 @@ module WebMock
 
     # RSpec 2 compatibility:
     alias_method :negative_failure_message, :failure_message_when_negated
+
+    private
+
+    ANY_URI = ->(_uri) { true }
+    private_constant :ANY_URI
+
+    # How the description of conditions starts when nothing was given to
+    # #with. What was given follows it, as in ' with body "abc"'.
+    EMPTY_CONDITIONS = RequestPattern.new(:any, ANY_URI).to_s.freeze
+    private_constant :EMPTY_CONDITIONS
+
+    def with_conditions(request_pattern)
+      @conditions ? PatternWithConditions.new(request_pattern, @conditions) : request_pattern
+    end
+
+    # Matches a request when both the pattern and the conditions match it.
+    class PatternWithConditions
+      def initialize(pattern, conditions)
+        @pattern = pattern
+        @conditions = conditions
+      end
+
+      # The parts that must all match, so JsonBodyHint can check each of them.
+      def patterns
+        [@pattern, @conditions]
+      end
+
+      def matches?(request_signature)
+        @pattern.matches?(request_signature) && @conditions.matches?(request_signature)
+      end
+
+      def to_s
+        "#{@pattern} (only requests#{@conditions.to_s.delete_prefix(EMPTY_CONDITIONS)})"
+      end
+    end
+    private_constant :PatternWithConditions
   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.29.0' unless defined?(::WebMock::VERSION)
+  VERSION = '3.34.0' unless defined?(::WebMock::VERSION)
 end

data/lib/webmock/webmock.rb

@@ -87,14 +87,12 @@ module WebMock
     when Array
       allowed.any? { |allowed_item| net_connect_explicit_allowed?(allowed_item, uri) }
     when Regexp
-      (uri.to_s =~ allowed) != nil ||
-      (uri.omit(:port).to_s =~ allowed) != nil && uri.port == uri.default_port
+      allowed.match?(uri.to_s) ||
+      (uri.port == uri.default_port && allowed.match?(uri.omit(:port).to_s))
     when String
-      allowed == uri.to_s ||
       allowed == uri.host ||
       allowed == "#{uri.host}:#{uri.port}" ||
-      allowed == "#{uri.scheme}://#{uri.host}:#{uri.port}" ||
-      allowed == "#{uri.scheme}://#{uri.host}" && uri.port == uri.default_port
+      net_connect_allowed_url?(allowed, uri)
     else
       if allowed.respond_to?(:call)
         allowed.call(uri)
@@ -102,6 +100,28 @@ module WebMock
     end
   end
 
+  def self.net_connect_allowed_url?(allowed, uri)
+    return false unless allowed.match?(%r{\Ahttps?://}i)
+
+    # Normalization turns an empty path into "/", so check the original URL.
+    allowed_uri = Addressable::URI.parse(allowed)
+    allow_any_path = allowed_uri.path.empty? && allowed_uri.query.nil?
+
+    # Connection URIs have no request path to match yet.
+    return false if uri.path.empty? && !allowed_uri.path.empty?
+
+    allowed_uri = WebMock::Util::URI.normalize_uri(allowed_uri)
+    request_uri = WebMock::Util::URI.normalize_uri(uri)
+
+    return false unless allowed_uri.origin == request_uri.origin
+    return true if allow_any_path
+
+    allowed_uri.path == request_uri.path && allowed_uri.query == request_uri.query
+  rescue Addressable::URI::InvalidURIError
+    false
+  end
+  private_class_method :net_connect_allowed_url?
+
   def self.show_body_diff!
     Config.instance.show_body_diff = true
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: webmock
 version: !ruby/object:Gem::Version
-  version: 3.29.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.29.0/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/webmock/3.29.0
-  source_code_uri: https://github.com/bblimke/webmock/tree/v3.29.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: