webmock 3.26.4 → 3.34.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb0293b4433bbf3342d1f81abb5a1c773382f6f1a7fef6b44eb83fc0a38544a7
-  data.tar.gz: 00fbb149216fae39f04b689fc02c0f561e59e47843011fd8aaab36b35e86ba67
+  metadata.gz: b66b694440da9739d8d23ccd8a260260739199235f076f4854387f7029c0c976
+  data.tar.gz: 96abe5bbe31e475bcec618aff66d43ac724b7cf15b08883ae864d62cac826e7c
 SHA512:
-  metadata.gz: 664302057fd929d144d09bb739c0cc581f4b80b40b67093989a4df01a21337f12594b765d9da0bc980ba981cfbe8db451cf0d23ce4ed10fa5d57eb2ddd98de79
-  data.tar.gz: bad8a582bd3b717e11182aef243b7167021187d63bd40b2dc1f0f54f13928e898e45ecf1cb598419e8dfc643d5b270db0d3a5408ab871ffb0725d5560dbd556b
+  metadata.gz: 99395c27d7c6c270f37309e69da7f3688c43b8f158327d23b62b9829b3fff7a667280542017c71f18e2b822de6639394b2aeaa078aae7b7c67d7fd497363e918
+  data.tar.gz: 9378a048d2a03b1309eff3b5264ddca35e4f9268399a92e98147fa0e2d60e376d31ca2f1ccaca912f6d7ca859268b1d9ce173530e885c5055b99f3c2632bfd46

data/CHANGELOG.md

@@ -1,5 +1,181 @@
 # 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)
+
+    Thanks to [Olivier Brisse](https://github.com/ouranos)
+
+* Ignore the case of JSON, XML and url-encoded content types when matching request bodies, and match bodies of any `+json` or `+xml` media type, such as `image/svg+xml`, as JSON or XML
+
+* Suggest declaring a JSON body as a hash when a request fails to match only because the JSON is formatted differently (#649)
+
+    A body declared as a string must match the request body exactly, including key order and whitespace. When that is the only difference, the error for an unregistered request and the failure message of a request expectation now say so, and suggest `with(body: JSON.parse(json_string))`. Matching JSON strings regardless of key order by default is planned for the next major version (#485).
+
+# 3.28.0
+
+* Fix `to_rack` apps receiving a `rack.session` they did not set up (#985)
+
+    WebMock used to add a session hash to the Rack env, shared by every request to the same stub. This confused apps that check whether a session is present, such as Rails API-only apps, and carried session data over between requests. WebMock now leaves `rack.session` and `rack.session.options` unset, as a real server does. If your app needs a session, include session middleware in the app you pass to `to_rack`. `RackResponse#session` and `RackResponse#session_options` have been removed.
+
+    Thanks to [Jan Graichen](https://github.com/jgraichen)
+
+* Fix crash when matching a hash body pattern against a JSON or XML request that has no body
+
+    Thanks to [Chris](https://github.com/ChrisJr404)
+
+* No longer warn about curb versions newer than the last one tested
+
+* Document regexp values in `hash_including`
+
+    Thanks to [Christian Bruckmayer](https://github.com/ChrisBr)
+
+* Remove unused `RequestSignatureSnippet#request_params`
+
+    Thanks to [Daniel Pepper](https://github.com/dpep)
+
+# 3.27.0
+
+* Fix crash in async-http adapter when a request header has a nil value
+
+    Thanks to [hikmetba-bit](https://github.com/hikmetba-bit)
+
+* The async-http adapter now matches stubs against raw request header values instead of values parsed by protocol-http, consistent with the other adapters
+
+* Add RSpec `hash_excluding` support to body matching
+
+    Thanks to [Chris Gunther](https://github.com/cgunther)
+
+* Fix `hash_excluding` ignoring keys given without a value and regexp values, in both query and body matching
+
+* Fix crash when matching a request that has more than one `Content-Type` header
+
 # 3.26.4
 
 * Fix race condition in `HTTPClient` adapter async requests by @koic in #1131

data/README.md

@@ -176,6 +176,8 @@ RestClient.post('www.example.com', '<data a="1" b="five" />',
   content_type: 'application/xml')    # ===> Success
 ```
 
+A body declared as a string must match the request body exactly. For JSON, that includes key order and whitespace, so declare the body as a hash to match it as JSON, for example `with(body: JSON.parse(json_string))`.
+
 ### Matching request body against partial hash.
 
 ```ruby
@@ -184,6 +186,24 @@ stub_request(:post, "www.example.com").
 
 RestClient.post('www.example.com', "data[a]=1&data[b]=five&x=1",
 :content_type => 'application/x-www-form-urlencoded')    # ===> Success
+
+stub_request(:post, "www.example.com").
+  with(body: hash_including(id: /\d/))
+
+RestClient.post('www.example.com', "id=1",
+:content_type => 'application/x-www-form-urlencoded')    # ===> Success
+```
+
+### Matching request body against excluding partial hash.
+
+```ruby
+stub_request(:post, "www.example.com").
+  with(body: hash_excluding({data: {a: '2', b: 'six'}}))
+
+RestClient.post('www.example.com', "data[a]=1&data[b]=five&x=1",
+:content_type => 'application/x-www-form-urlencoded')    # ===> Success
+RestClient.post('www.example.com', "data[a]=2&data[b]=six&x=1",
+:content_type => 'application/x-www-form-urlencoded')    # ===> Failure
 ```
 
 ### Matching custom request headers
@@ -279,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
@@ -343,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
@@ -426,6 +469,8 @@ stub_request(:get, "www.example.com").to_rack(MyRackApp)
 RestClient.post('www.example.com')    # ===> "Hello"
 ```
 
+WebMock does not set `rack.session` in the Rack env, just as a real server would not. If your app needs a session, include session middleware in the app you pass to `to_rack`.
+
 ### Raising errors
 
 #### Exception declared by class
@@ -551,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
@@ -615,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
@@ -729,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

@@ -111,11 +111,23 @@ if defined?(Async::HTTP)
           WebMock::RequestSignature.new(
             request.method.downcase.to_sym,
             "#{request.scheme}://#{request.authority}#{request.path}",
-            headers: request.headers.to_h,
+            headers: build_request_headers(request),
             body: body
           )
         end
 
+        # Protocol::HTTP::Headers#to_h parses values through the header policies
+        # (since protocol-http 0.56.0) and raises when a value is nil. Build the
+        # hash from the raw fields instead, skipping entries with no value since
+        # they carry nothing to match against. Keys are downcased so the same
+        # header sent in different casings is grouped together.
+        def build_request_headers(request)
+          request.headers.each.each_with_object({}) do |(key, value), headers|
+            next if value.nil?
+            (headers[key.downcase] ||= []) << value
+          end
+        end
+
         def build_webmock_response(response)
           body = response.read
           response.body = ::Protocol::HTTP::Body::Buffered.wrap(body)
@@ -195,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
@@ -221,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

@@ -13,7 +13,7 @@ if defined?(Curl)
   # in curb 1.3.0 through 1.3.5. Fixed in curb 1.3.6. See https://github.com/taf2/curb/issues/478
   unsupported_curb_versions += %w[1.3.0 1.3.1 1.3.2 1.3.3 1.3.4 1.3.5] if RUBY_VERSION < '2.7'
 
-  WebMock::VersionChecker.new('Curb', Curl::CURB_VERSION, '0.7.16', '1.3.7', unsupported_curb_versions).check_version!
+  WebMock::VersionChecker.new('Curb', Curl::CURB_VERSION, '0.7.16', nil, unsupported_curb_versions).check_version!
 
   module WebMock
     module HttpLibAdapters
@@ -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