webmock 3.29.0 → 3.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd5a0e377558900faf49baabeca47478c71196acd38c625b30ed13d48cb3945a
-  data.tar.gz: 7956de226b2fa9ad8f692319e6ea5ea4ca666c77c48488feb58470e79474ce26
+  metadata.gz: fd3966eb9bb71d2c1ef49c389d9f0a90520cd662cd2a2a10d36568eaadbffa33
+  data.tar.gz: ec1209ad4ec45fce69665fd4e64a1f59743716a043e42b3e63b8bcddced6911a
 SHA512:
-  metadata.gz: dd9d32d168c7a3e3719b467c519393158cf1b279213acc1e515ac0ff1f88f4f60bc4831e975eae23d18b2fb0d08c84390b180ce52f68a492852d1981dfa5e29d
-  data.tar.gz: e4bb8d187695bde02c1bcadd89923b24d26e2174676f094ac93cc551e5e5688b242ee519c565151ad7423162557d47ee86bb97c981529134ae4bebfccbd4d5d2
+  metadata.gz: 58a66d8ce0f9f893d8862835d28728e585a8ebd2ff074a64b7a88b09508aa2caeb3181e62cfd7adcef7df67da463aa50c1718b6955aa4bf34f42d5fde35a9575
+  data.tar.gz: 3105e385e8f5aa63acf07a874a8d93100f3f8d739aae9d56cfe77e479576afe91541af70aa3a739828c59c170c2adb86335e2ad635b20b1c8941266e28a88202

data/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+# 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

@@ -363,6 +363,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 +587,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 +666,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 +782,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/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/request_pattern.rb

@@ -14,7 +14,7 @@ module WebMock
 
   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 +94,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)

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module WebMock
-  VERSION = '3.29.0' unless defined?(::WebMock::VERSION)
+  VERSION = '3.31.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.31.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.31.0/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/webmock/3.31.0
+  source_code_uri: https://github.com/bblimke/webmock/tree/v3.31.0
   wiki_uri: https://github.com/bblimke/webmock/wiki
 rdoc_options: []
 require_paths: