webmock 3.16.2 → 3.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 438dab0f90920381d01009b8c75892ac83e46043e170c17e1dba5e46ca755c61
-  data.tar.gz: a760f4b2399f465c62cf03268c13a7ae973900945ed0c4631e146c44f688a97d
+  metadata.gz: 70c0ad15601d48c3f413012ced7fde245d03fcc5d5bb7b609fd2ce89084b2589
+  data.tar.gz: 4575309d868350685b573d8929ce1836eb044b00fb862c1b9b266a73a1992e9f
 SHA512:
-  metadata.gz: c8033597431b3e8ce43e60837d31f18d1ffa52c35079827e122a4616587f29b480b2340786c841bbe9f6b9390c5df08e9b84e933160412c8dc1d5c8a9b214f8b
-  data.tar.gz: e0580a7b6b712073edf7d6c38fbf7b6df00a294aa9910f1de0e2de61535de67d07315b5d10f141d7e3387bf91aaee7ce6bb204d40190b5357b2120dc0d7d4427
+  metadata.gz: acba1ac0ec3d97c5eb244a84d1b8e895f13e9b3cfb1ca5ac4c0d5109eb7fcc508a3d1e51faa426bd31cb2509d61effed7c134119b5c05d128b3466ec3ee397c7
+  data.tar.gz: e8eb5385dd3d4fc9f02c541fbec1bc2c825e07445046b3bde50c471925728c08b1bb9aaf963d61fb44f5a38041f54964ab9fa89caef4cd16fd06fe6bb1ceca44

data/CHANGELOG.md

@@ -1,14 +1,50 @@
 # Changelog
 
-# 3.16.2
+# 3.18.0
+
+  * Net::BufferedIO is not replaced anymore.
+
+    Thanks to [Ray Zane](https://github.com/rzane)
+
+  * Simplified connection handing in Net::HTTP adapter.
+
+    Thanks to [Ray Zane](https://github.com/rzane)
 
-  * Minimum required Ruby version is 2.0 again.
+# 3.17.1
 
-# 3.16.1
+  * Fixed Syntax Error
+
+    Thanks to [Mark Spangler](https://github.com/mspangler)
+
+# 3.17.0
 
   * Minimum required Ruby version is 2.3
 
-# 3.16.0
+    Thanks to [Go Sueyoshi](https://github.com/sue445)
+
+  * When using Net::HTTP, stubbed socket StubSocket#close and StubSocket#closed? behave more like the real sockets.
+
+    Thanks to [Ray Zane](https://github.com/rzane)
+
+  * Added `peeraddr`, `ssl_version` and `cipher` methods to stubbed sockets used by Net::HTTP.
+
+    Thanks to [Ray Zane](https://github.com/rzane)
+
+  * Added support for matching top-level array in JSON request body.
+
+    E.g.
+
+      ````
+      stub_request(:post, 'www.example.com').with(body: [{a: 1}])
+      ````
+
+    Thanks to [Cedric Sohrauer](https://github.com/cedrics)
+
+# 3.16.2
+
+  * Minimum required Ruby version is 2.0.
+
+# 3.16.0 (yanked)
 
   * Fix leaky file descriptors and reuse socket for persistent connections.
 
@@ -18,7 +54,11 @@
 
     Thanks to [Ray Zane](https://github.com/rzane)
 
-# 3.15.0
+# 3.15.2
+
+  * Minimum required Ruby version is 2.0.
+
+# 3.15.0 (yanked)
 
   * fixed async-http adapter on Windows
 

data/README.md

@@ -1166,13 +1166,17 @@ People who submitted patches and new features or suggested improvements. Many th
 * Timmitry
 * Michael Fairley
 * Ray Zane
+* Go Sueyoshi
+* Cedric Sohrauer
+* Akira Matsuda
+* Mark Spangler
 
 For a full list of contributors you can visit the
 [contributors](https://github.com/bblimke/webmock/contributors) page.
 
 ## Background
 
-Thank you Fakeweb! This library was inspired by [FakeWeb](http://fakeweb.rubyforge.org).
+Thank you Fakeweb! This library was inspired by [FakeWeb](https://github.com/chrisk/fakeweb).
 I imported some solutions from that project to WebMock. I also copied some code i.e Net:HTTP adapter.
 Fakeweb architecture unfortunately didn't allow me to extend it easily with the features I needed.
 I also preferred some things to work differently i.e request stub precedence.

data/lib/webmock/http_lib_adapters/net_http.rb

@@ -10,24 +10,19 @@ module WebMock
       adapter_for :net_http
 
       OriginalNetHTTP = Net::HTTP unless const_defined?(:OriginalNetHTTP)
-      OriginalNetBufferedIO = Net::BufferedIO unless const_defined?(:OriginalNetBufferedIO)
 
       def self.enable!
-        Net.send(:remove_const, :BufferedIO)
         Net.send(:remove_const, :HTTP)
         Net.send(:remove_const, :HTTPSession)
         Net.send(:const_set, :HTTP, @webMockNetHTTP)
         Net.send(:const_set, :HTTPSession, @webMockNetHTTP)
-        Net.send(:const_set, :BufferedIO, Net::WebMockNetBufferedIO)
       end
 
       def self.disable!
-        Net.send(:remove_const, :BufferedIO)
         Net.send(:remove_const, :HTTP)
         Net.send(:remove_const, :HTTPSession)
         Net.send(:const_set, :HTTP, OriginalNetHTTP)
         Net.send(:const_set, :HTTPSession, OriginalNetHTTP)
-        Net.send(:const_set, :BufferedIO, OriginalNetBufferedIO)
 
         #copy all constants from @webMockNetHTTP to original Net::HTTP
         #in case any constants were added to @webMockNetHTTP instead of Net::HTTP
@@ -72,74 +67,57 @@ module WebMock
         end
 
         def request(request, body = nil, &block)
+          return super unless started?
+
           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
             WebMock::CallbackRegistry.invoke_callbacks(
               {lib: :net_http}, request_signature, webmock_response)
             build_net_http_response(webmock_response, &block)
           elsif WebMock.net_connect_allowed?(request_signature.uri)
             check_right_http_connection
-            after_request = lambda do |response|
-              if WebMock::CallbackRegistry.any_callbacks?
-                webmock_response = build_webmock_response(response)
-                WebMock::CallbackRegistry.invoke_callbacks(
-                  {lib: :net_http, real_request: true}, request_signature, webmock_response)
-              end
-              response.extend Net::WebMockHTTPResponse
-              block.call response if block
-              response
-            end
-            super_with_after_request = lambda {
-              response = super(request, nil, &nil)
-              after_request.call(response)
-            }
-            if started?
-              ensure_actual_connection
-              super_with_after_request.call
-            else
-              start_with_connect {
-                super_with_after_request.call
-              }
+            ensure_actually_connected
+
+            response = super(request, nil, &nil)
+
+            if WebMock::CallbackRegistry.any_callbacks?
+              WebMock::CallbackRegistry.invoke_callbacks(
+                {lib: :net_http, real_request: true},
+                request_signature,
+                build_webmock_response(response)
+              )
             end
+
+            response.extend Net::WebMockHTTPResponse
+            block.call response if block
+            response
           else
             raise WebMock::NetConnectNotAllowedError.new(request_signature)
           end
         end
 
-        def start_without_connect
-          raise IOError, 'HTTP session already opened' if @started
-          if block_given?
-            begin
-              @socket = Net::HTTP.socket_type.new
-              @started = true
-              return yield(self)
-            ensure
-              do_finish
-            end
-          end
-          @socket = Net::HTTP.socket_type.new
-          @started = true
-          self
-        end
-
-
-        def ensure_actual_connection
-          do_start if @socket.is_a?(StubSocket)
-        end
+        private
 
-        alias_method :start_with_connect, :start
+        alias_method :actually_connect, :connect
 
-        def start(&block)
+        def connect
           uri = Addressable::URI.parse(WebMock::NetHTTPUtility.get_uri(self))
 
           if WebMock.net_http_connect_on_start?(uri)
-            super(&block)
+            super
           else
-            start_without_connect(&block)
+            @socket = StubSocket.new
+          end
+        end
+
+        def ensure_actually_connected
+          if @socket.is_a?(StubSocket)
+            @socket&.close
+            @socket = nil
+            actually_connect
           end
         end
 
@@ -161,7 +139,7 @@ module WebMock
           response.extend Net::WebMockHTTPResponse
 
           if webmock_response.should_timeout
-            raise timeout_exception, "execution expired"
+            raise Net::OpenTimeout, "execution expired"
           end
 
           webmock_response.raise_error_if_any
@@ -171,16 +149,6 @@ module WebMock
           response
         end
 
-        def timeout_exception
-          if defined?(Net::OpenTimeout)
-            # Ruby 2.x
-            Net::OpenTimeout
-          else
-            # Fallback, if things change
-            Timeout::Error
-          end
-        end
-
         def build_webmock_response(net_http_response)
           webmock_response = WebMock::Response.new
           webmock_response.status = [
@@ -214,31 +182,21 @@ module WebMock
   end
 end
 
-# patch for StringIO behavior in Ruby 2.2.3
-# https://github.com/bblimke/webmock/issues/558
-class PatchedStringIO < StringIO #:nodoc:
-
-  alias_method :orig_read_nonblock, :read_nonblock
-
-  def read_nonblock(size, *args, **kwargs)
-    args.reject! {|arg| !arg.is_a?(Hash)}
-    orig_read_nonblock(size, *args, **kwargs)
-  end
-
-end
-
 class StubSocket #:nodoc:
 
   attr_accessor :read_timeout, :continue_timeout, :write_timeout
 
   def initialize(*args)
+    @closed = false
   end
 
   def closed?
-    @closed ||= true
+    @closed
   end
 
   def close
+    @closed = true
+    nil
   end
 
   def readuntil(*args)
@@ -251,57 +209,12 @@ class StubSocket #:nodoc:
   class StubIO
     def setsockopt(*args); end
     def peer_cert; end
+    def peeraddr; ["AF_INET", 443, "127.0.0.1", "127.0.0.1"] end
+    def ssl_version; "TLSv1.3" end
+    def cipher; ["TLS_AES_128_GCM_SHA256", "TLSv1.3", 128, 128] end
   end
 end
 
-module Net  #:nodoc: all
-
-  class WebMockNetBufferedIO < BufferedIO
-    def initialize(io, *args, **kwargs)
-      io = case io
-      when Socket, OpenSSL::SSL::SSLSocket, IO
-        io
-      when StringIO
-        PatchedStringIO.new(io.string)
-      when String
-        PatchedStringIO.new(io)
-      end
-      raise "Unable to create local socket" unless io
-
-      # Prior to 2.4.0 `BufferedIO` only takes a single argument (`io`) with no
-      # options. Here we pass through our full set of arguments only if we're
-      # on 2.4.0 or later, and use a simplified invocation otherwise.
-      if RUBY_VERSION >= '2.4.0'
-        super
-      else
-        super(io)
-      end
-    end
-
-    if RUBY_VERSION >= '2.6.0'
-      # https://github.com/ruby/ruby/blob/7d02441f0d6e5c9d0a73a024519eba4f69e36dce/lib/net/protocol.rb#L208
-      # Modified version of method from ruby, so that nil is always passed into orig_read_nonblock to avoid timeout
-      def rbuf_fill
-        case rv = @io.read_nonblock(BUFSIZE, nil, exception: false)
-        when String
-          return if rv.nil?
-          @rbuf << rv
-          rv.clear
-          return
-        when :wait_readable
-          @io.to_io.wait_readable(@read_timeout) or raise Net::ReadTimeout
-        when :wait_writable
-          @io.to_io.wait_writable(@read_timeout) or raise Net::ReadTimeout
-        when nil
-          raise EOFError, 'end of file reached'
-        end while true
-      end
-    end
-  end
-
-end
-
-
 module WebMock
   module NetHTTPUtility
 
@@ -318,7 +231,6 @@ module WebMock
       method = request.method.downcase.to_sym
 
       headers = Hash[*request.to_hash.map {|k,v| [k, v]}.inject([]) {|r,x| r + x}]
-      validate_headers(headers)
 
       if request.body_stream
         body = request.body_stream.read
@@ -343,25 +255,6 @@ module WebMock
       "#{protocol}://#{hostname}:#{net_http.port}#{path}"
     end
 
-    def self.validate_headers(headers)
-      # For Ruby versions < 2.3.0, if you make a request with headers that are symbols
-      # Net::HTTP raises a NoMethodError
-      #
-      # WebMock normalizes headers when creating a RequestSignature,
-      # and will update all headers from symbols to strings.
-      #
-      # This could create a false positive in a test suite with WebMock.
-      #
-      # So before this point, WebMock raises an ArgumentError if any of the headers are symbols
-      # instead of the cryptic NoMethodError "undefined method `split' ...` from Net::HTTP
-      if Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('2.3.0')
-        header_as_symbol = headers.keys.find {|header| header.is_a? Symbol}
-        if header_as_symbol
-          raise ArgumentError.new("Net:HTTP does not accept headers as symbols")
-        end
-      end
-    end
-
     def self.check_right_http_connection
       @was_right_http_connection_loaded = defined?(RightHttpConnection)
     end

data/lib/webmock/request_pattern.rb

@@ -281,6 +281,8 @@ module WebMock
       if (@pattern).is_a?(Hash)
         return true if @pattern.empty?
         matching_body_hashes?(body_as_hash(body, content_type), @pattern, content_type)
+      elsif (@pattern).is_a?(Array)
+        matching_body_array?(body_as_hash(body, content_type), @pattern, content_type)
       elsif (@pattern).is_a?(WebMock::Matchers::HashIncludingMatcher)
         @pattern == body_as_hash(body, content_type)
       else
@@ -344,19 +346,33 @@ module WebMock
     def matching_body_hashes?(query_parameters, pattern, content_type)
       return false unless query_parameters.is_a?(Hash)
       return false unless query_parameters.keys.sort == pattern.keys.sort
-      query_parameters.each do |key, actual|
+
+      query_parameters.all? do |key, actual|
         expected = pattern[key]
+        matching_values(actual, expected, content_type)
+      end
+    end
 
-        if actual.is_a?(Hash) && expected.is_a?(Hash)
-          return false unless matching_body_hashes?(actual, expected, content_type)
-        else
-          expected = WebMock::Util::ValuesStringifier.stringify_values(expected) if url_encoded_body?(content_type)
-          return false unless expected === actual
-        end
+    def matching_body_array?(query_parameters, pattern, content_type)
+      return false unless query_parameters.is_a?(Array)
+      return false unless query_parameters.length == pattern.length
+
+      query_parameters.each_with_index do |actual, index|
+        expected = pattern[index]
+        return false unless matching_values(actual, expected, content_type)
       end
+
       true
     end
 
+    def matching_values(actual, expected, content_type)
+      return matching_body_hashes?(actual, expected, content_type) if actual.is_a?(Hash) && expected.is_a?(Hash)
+      return matching_body_array?(actual, expected, content_type) if actual.is_a?(Array) && expected.is_a?(Array)
+
+      expected = WebMock::Util::ValuesStringifier.stringify_values(expected) if url_encoded_body?(content_type)
+      expected === actual
+    end
+
     def empty_string?(string)
       string.nil? || string == ""
     end

data/lib/webmock/request_signature.rb

@@ -35,11 +35,11 @@ module WebMock
     alias == eql?
 
     def url_encoded?
-      !!(headers && headers.fetch('Content-Type', "").start_with?('application/x-www-form-urlencoded'))
+      !!(headers&.fetch('Content-Type', nil)&.start_with?('application/x-www-form-urlencoded'))
     end
 
     def json_headers?
-      !!(headers && headers.fetch('Content-Type', "").start_with?('application/json'))
+      !!(headers&.fetch('Content-Type', nil)&.start_with?('application/json'))
     end
 
     private

data/lib/webmock/response.rb

@@ -14,8 +14,11 @@ module WebMock
 
   class Response
     def initialize(options = {})
-      if options.is_a?(IO) || options.is_a?(String)
+      case options
+      when IO, StringIO
         self.options = read_raw_response(options)
+      when String
+        self.options = read_raw_response(StringIO.new(options))
       else
         self.options = options
       end
@@ -120,13 +123,8 @@ module WebMock
       end
     end
 
-    def read_raw_response(raw_response)
-      if raw_response.is_a?(IO)
-        string = raw_response.read
-        raw_response.close
-        raw_response = string
-      end
-      socket = ::Net::BufferedIO.new(raw_response)
+    def read_raw_response(io)
+      socket = ::Net::BufferedIO.new(io)
       response = ::Net::HTTPResponse.read_new(socket)
       transfer_encoding = response.delete('transfer-encoding') #chunks were already read by curl
       response.reading_body(socket, true) {}
@@ -138,6 +136,8 @@ module WebMock
       options[:body] = response.read_body
       options[:status] = [response.code.to_i, response.message]
       options
+    ensure
+      socket.close
     end
 
     InvalidBody = Class.new(StandardError)

data/lib/webmock/version.rb

@@ -1,3 +1,3 @@
 module WebMock
-  VERSION = '3.16.2' unless defined?(::WebMock::VERSION)
+  VERSION = '3.18.0' unless defined?(::WebMock::VERSION)
 end

data/spec/acceptance/net_http/net_http_spec.rb

@@ -115,33 +115,16 @@ describe "Net:HTTP" do
     expect(Net::HTTP.start("www.example.com") { |http| http.request(req)}.body).to eq("abc")
   end
 
-  it "raises an ArgumentError if passed headers as symbols if RUBY_VERSION < 2.3.0" do
+  it "raises an ArgumentError if passed headers as symbols" do
     uri = URI.parse("http://google.com/")
     http = Net::HTTP.new(uri.host, uri.port)
     request = Net::HTTP::Get.new(uri.request_uri)
+    request[:InvalidHeaderSinceItsASymbol] = "this will not be valid"
 
-    # Net::HTTP calls downcase on header keys assigned with []=
-    # In Ruby 1.8.7 symbols do not respond to downcase
-    #
-    # Meaning you can not assign header keys as symbols in ruby 1.8.7 using []=
-    if :symbol.respond_to?(:downcase)
-      request[:InvalidHeaderSinceItsASymbol] = "this will not be valid"
-    else
-      request.instance_eval do
-        @header = request.to_hash.merge({InvalidHeaderSinceItsASymbol: "this will not be valid"})
-      end
-    end
-
-    if Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('2.3.0')
-      expect do
-        http.request(request)
-      end.to raise_error ArgumentError, "Net:HTTP does not accept headers as symbols"
-    else
-      stub_http_request(:get, "google.com").with(headers: { InvalidHeaderSinceItsASymbol: "this will not be valid" })
-      expect do
-        http.request(request)
-      end.not_to raise_error
-    end
+    stub_http_request(:get, "google.com").with(headers: { InvalidHeaderSinceItsASymbol: "this will not be valid" })
+    expect do
+      http.request(request)
+    end.not_to raise_error
   end
 
   it "should handle multiple values for the same response header" do
@@ -213,6 +196,22 @@ describe "Net:HTTP" do
     end
   end
 
+  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7.0')
+    it "uses the StubSocket to provide IP address" do
+      Net::HTTP.start("example.com") do |http|
+        expect(http.ipaddr).to eq("127.0.0.1")
+      end
+    end
+  end
+
+  it "defines common socket methods" do
+    Net::HTTP.start("example.com") do |http|
+      socket = http.instance_variable_get(:@socket)
+      expect(socket.io.ssl_version).to eq("TLSv1.3")
+      expect(socket.io.cipher).to eq(["TLS_AES_128_GCM_SHA256", "TLSv1.3", 128, 128])
+    end
+  end
+
   describe "connecting on Net::HTTP.start" do
     before(:each) do
       @http = Net::HTTP.new('www.google.com', 443)

data/spec/acceptance/patron/patron_spec.rb

@@ -93,31 +93,29 @@ unless RUBY_PLATFORM =~ /java/
         @sess.copy("/abc", "/def")
       end
 
-      if /^1\.9/ === RUBY_VERSION
-        describe "handling encoding same way as patron" do
-          around(:each) do |example|
-            @encoding = Encoding.default_internal
-            Encoding.default_internal = "UTF-8"
-            example.run
-            Encoding.default_internal = @encoding
-          end
+      describe "handling encoding same way as patron" do
+        around(:each) do |example|
+          @encoding = Encoding.default_internal
+          Encoding.default_internal = "UTF-8"
+          example.run
+          Encoding.default_internal = @encoding
+        end
 
-          it "should not encode body with default encoding" do
-            stub_request(:get, "www.example.com").
-              to_return(body: "Øl")
+        it "should not encode body with default encoding" do
+          stub_request(:get, "www.example.com").
+            to_return(body: "Øl")
 
-            expect(@sess.get("").body.encoding).to eq(Encoding::ASCII_8BIT)
-            expect(@sess.get("").inspectable_body.encoding).to eq(Encoding::UTF_8)
-          end
+          expect(@sess.get("").body.encoding).to eq(Encoding::ASCII_8BIT)
+          expect(@sess.get("").inspectable_body.encoding).to eq(Encoding::UTF_8)
+        end
 
-          it "should not encode body to default internal" do
-            stub_request(:get, "www.example.com").
-              to_return(headers: {'Content-Type' => 'text/html; charset=iso-8859-1'},
-                        body: "Øl".encode("iso-8859-1"))
+        it "should not encode body to default internal" do
+          stub_request(:get, "www.example.com").
+            to_return(headers: {'Content-Type' => 'text/html; charset=iso-8859-1'},
+                      body: "Øl".encode("iso-8859-1"))
 
-            expect(@sess.get("").body.encoding).to eq(Encoding::ASCII_8BIT)
-            expect(@sess.get("").decoded_body.encoding).to eq(Encoding.default_internal)
-          end
+          expect(@sess.get("").body.encoding).to eq(Encoding::ASCII_8BIT)
+          expect(@sess.get("").decoded_body.encoding).to eq(Encoding.default_internal)
         end
       end
     end

data/spec/unit/request_pattern_spec.rb

@@ -547,6 +547,18 @@ describe WebMock::RequestPattern do
                                                            body: "{\"a\":\"1\",\"b\":\"five\",\"c\":{\"d\":[\"e\",\"f\"]}}"))
                 end
 
+            it "should match if the request body has a top level array" do
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: [{a: 1}])).
+                to match(WebMock::RequestSignature.new(:post, "www.example.com",
+                headers: {content_type: content_type}, body: "[{\"a\":1}]"))
+            end
+
+            it "should not match if the request body has a different top level array" do
+              expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: ["a", "b"])).
+                not_to match(WebMock::RequestSignature.new(:post, "www.example.com",
+                headers: {content_type: content_type}, body: "[\"a\", \"c\"]"))
+            end
+
             it "should not match when body is not json" do
               expect(WebMock::RequestPattern.new(:post, 'www.example.com', body: body_hash)).
                 not_to match(WebMock::RequestSignature.new(:post, "www.example.com",

data/spec/unit/response_spec.rb

@@ -142,6 +142,34 @@ describe WebMock::Response do
   end
 
   describe "from raw response" do
+    describe "when input is a StringIO" do
+      before(:each) do
+        @io = StringIO.new(File.read(CURL_EXAMPLE_OUTPUT_PATH))
+        @response = WebMock::Response.new(@io)
+      end
+
+      it "should read status" do
+        expect(@response.status).to eq([202, "OK"])
+      end
+
+      it "should read headers" do
+        expect(@response.headers).to eq(
+          "Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
+          "Content-Type"=>"text/html; charset=UTF-8",
+          "Content-Length"=>"419",
+          "Connection"=>"Keep-Alive",
+          "Accept"=>"image/jpeg, image/png"
+        )
+      end
+
+      it "should read body" do
+        expect(@response.body.size).to eq(419)
+      end
+
+      it "should close IO" do
+        expect(@io).to be_closed
+      end
+    end
 
     describe "when input is IO" do
       before(:each) do

data/webmock.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ['Bartosz Blimke']
   s.email       = ['bartosz.blimke@gmail.com']
-  s.homepage    = 'http://github.com/bblimke/webmock'
+  s.homepage    = 'https://github.com/bblimke/webmock'
   s.summary     = %q{Library for stubbing HTTP requests in Ruby.}
   s.description = %q{WebMock allows stubbing HTTP requests and setting expectations on HTTP requests.}
   s.license     = "MIT"
@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
     'wiki_uri'          => 'https://github.com/bblimke/webmock/wiki'
   }
 
-  s.required_ruby_version = '>= 2.0'
+  s.required_ruby_version = '>= 2.3'
 
   s.add_dependency 'addressable', '>= 2.8.0'
   s.add_dependency 'crack', '>= 0.3.2'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: webmock
 version: !ruby/object:Gem::Version
-  version: 3.16.2
+  version: 3.18.0
 platform: ruby
 authors:
 - Bartosz Blimke
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-10 00:00:00.000000000 Z
+date: 2022-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -416,14 +416,14 @@ files:
 - test/test_helper.rb
 - test/test_webmock.rb
 - webmock.gemspec
-homepage: http://github.com/bblimke/webmock
+homepage: https://github.com/bblimke/webmock
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/bblimke/webmock/issues
-  changelog_uri: https://github.com/bblimke/webmock/blob/v3.16.2/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/webmock/3.16.2
-  source_code_uri: https://github.com/bblimke/webmock/tree/v3.16.2
+  changelog_uri: https://github.com/bblimke/webmock/blob/v3.18.0/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/webmock/3.18.0
+  source_code_uri: https://github.com/bblimke/webmock/tree/v3.18.0
   wiki_uri: https://github.com/bblimke/webmock/wiki
 post_install_message:
 rdoc_options: []
@@ -433,14 +433,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.0.3
 signing_key:
 specification_version: 4
 summary: Library for stubbing HTTP requests in Ruby.