webmock 3.0.1 → 3.18.1

data/README.md

@@ -1,6 +1,11 @@
 WebMock
 =======
-[![Gem Version](https://badge.fury.io/rb/webmock.svg)](http://badge.fury.io/rb/webmock) [![Build Status](https://secure.travis-ci.org/bblimke/webmock.svg?branch=master)](http://travis-ci.org/bblimke/webmock) [![Dependency Status](https://gemnasium.com/bblimke/webmock.svg)](http://gemnasium.com/bblimke/webmock) [![Code Climate](https://codeclimate.com/github/bblimke/webmock/badges/gpa.svg)](https://codeclimate.com/github/bblimke/webmock) [![Inline docs](http://inch-ci.org/github/bblimke/webmock.svg?branch=master)](http://inch-ci.org/github/bblimke/webmock)
+[![Gem Version](https://badge.fury.io/rb/webmock.svg)](http://badge.fury.io/rb/webmock)
+[![Build Status](https://github.com/bblimke/webmock/workflows/CI/badge.svg?branch=master)](https://github.com/bblimke/webmock/actions)
+[![Code Climate](https://codeclimate.com/github/bblimke/webmock/badges/gpa.svg)](https://codeclimate.com/github/bblimke/webmock)
+[![Mentioned in Awesome Ruby](https://awesome.re/mentioned-badge.svg)](https://github.com/markets/awesome-ruby)
+[![Inline docs](http://inch-ci.org/github/bblimke/webmock.svg?branch=master)](http://inch-ci.org/github/bblimke/webmock)
+[![SemVer](https://api.dependabot.com/badges/compatibility_score?dependency-name=webmock&package-manager=bundler&version-scheme=semver)](https://dependabot.com/compatibility-score.html?dependency-name=webmock&package-manager=bundler&version-scheme=semver)
 
 Library for stubbing and setting expectations on HTTP requests in Ruby.
 
@@ -19,30 +24,42 @@ Features
 Supported HTTP libraries
 ------------------------
 
-* Net::HTTP and libraries based on Net::HTTP (i.e RightHttpConnection, REST Client, HTTParty)
-* HTTPClient
-* Patron
-* EM-HTTP-Request
-* Curb (currently only Curb::Easy)
-* Typhoeus (currently only Typhoeus::Hydra)
-* Excon
-* HTTP Gem
-* Manticore
+* [Async::HTTP::Client](https://github.com/socketry/async-http)
+* [Curb](https://github.com/taf2/curb) (currently only Curb::Easy)
+* [EM-HTTP-Request](https://github.com/igrigorik/em-http-request)
+* [Excon](https://github.com/excon/excon)
+* [HTTPClient](https://github.com/nahi/httpclient)
+* [HTTP Gem (also known as http.rb)](https://github.com/httprb/http)
+* [httpx](https://honeyryderchuck.gitlab.io/httpx/wiki/Webmock-Adapter)
+* [Manticore](https://github.com/cheald/manticore)
+* [Net::HTTP](https://ruby-doc.org/stdlib-2.7.0/libdoc/net/http/rdoc/Net/HTTP.html) and other libraries based on Net::HTTP, e.g.:
+  * [HTTParty](https://github.com/jnunemaker/httparty)
+  * [REST Client](https://github.com/rest-client/rest-client)
+* [Patron](https://github.com/toland/patron)
+* [Typhoeus](https://github.com/typhoeus/typhoeus) (currently only Typhoeus::Hydra)
 
 Supported Ruby Interpreters
 ---------------------------
 
-* MRI 2.0
-* MRI 2.1
-* MRI 2.2
-* MRI 2.3
-* MRI 2.4
+* MRI 2.5
+* MRI 2.6
+* MRI 2.7
 * JRuby
 * Rubinius
 
 ## Installation
 
+```bash
     gem install webmock
+```
+or alternatively:
+
+```ruby
+    # add to your Gemfile
+    group :test do
+        gem "webmock"
+    end
+```
 
 ### or to install the latest development version from github master
 
@@ -54,36 +71,36 @@ Supported Ruby Interpreters
 
 WebMock 2.x has changed somewhat since version 1.x. Changes are listed in [CHANGELOG.md](CHANGELOG.md)
 
-### Test::Unit
+### Cucumber
 
-Add the following code to `test/test_helper.rb`
+Create a file `features/support/webmock.rb` with the following contents:
 
 ```ruby
-require 'webmock/test_unit'
+require 'webmock/cucumber'
 ```
 
-### RSpec
+### MiniTest
 
-Add the following code to `spec/spec_helper`:
+Add the following code to `test/test_helper`:
 
 ```ruby
-require 'webmock/rspec'
+require 'webmock/minitest'
 ```
 
-### MiniTest
+### RSpec
 
-Add the following code to `test/test_helper`:
+Add the following code to `spec/spec_helper`:
 
 ```ruby
-require 'webmock/minitest'
+require 'webmock/rspec'
 ```
 
-### Cucumber
+### Test::Unit
 
-Create a file `features/support/webmock.rb` with the following contents:
+Add the following code to `test/test_helper.rb`
 
 ```ruby
-require 'webmock/cucumber'
+require 'webmock/test_unit'
 ```
 
 ### Outside a test framework
@@ -97,13 +114,10 @@ include WebMock::API
 WebMock.enable!
 ```
 
-## Examples
-
-
+# Examples
 
 ## Stubbing
 
-
 ### Stubbed request based on uri only and with the default response
 
 ```ruby
@@ -236,6 +250,12 @@ stub_request(:any, /example/)
 Net::HTTP.get('www.example.com', '/')    # ===> Success
 ```
 
+### Matching uris using lambda
+
+```ruby
+stub_request(:any, ->(uri) { true })
+```
+
 ### Matching uris using RFC 6570 - Basic Example
 
 ```ruby
@@ -273,6 +293,16 @@ stub_request(:get, "www.example.com").
 RestClient.get("http://www.example.com/?a[]=b&a[]=c&x=1")    # ===> Success
 ```
 
+### Matching partial query params using hash_excluding
+
+```ruby
+stub_request(:get, "www.example.com").
+  with(query: hash_excluding({"a" => "b"}))
+
+RestClient.get("http://www.example.com/?a=b")    # ===> Failure
+RestClient.get("http://www.example.com/?a=c")    # ===> Success
+```
+
 ### Stubbing with custom response
 
 ```ruby
@@ -283,6 +313,12 @@ stub_request(:any, "www.example.com").
 Net::HTTP.get("www.example.com", '/')    # ===> "abc"
 ```
 
+Set appropriate Content-Type for HTTParty's `parsed_response`.
+
+```ruby
+stub_request(:any, "www.example.com").to_return body: '{}', headers: {content_type: 'application/json'}
+```
+
 ### Response with body specified as IO object
 
 ```ruby
@@ -514,9 +550,9 @@ RestClient.get('sample.org', '/bar')          # ===> Failure
 With an object that responds to `#call`, receiving a `URI` object and returning a boolean:
 
 ```ruby
-blacklist = ['google.com', 'facebook.com', 'apple.com']
+denylist = ['google.com', 'facebook.com', 'apple.com']
 allowed_sites = lambda{|uri|
-  blacklist.none?{|site| uri.host.include?(site) }
+  denylist.none?{|site| uri.host.include?(site) }
 }
 WebMock.disable_net_connect!(allow: allowed_sites)
 
@@ -696,6 +732,28 @@ Net::HTTP.get('www.example.com', '/')    # ===> Failure
 assert_not_requested :get, "www.example.com"    # ===> Success
 ```
 
+## Clearing request counters
+
+If you want to reset **only** the counters of the executed requests use `WebMock.reset_executed_requests!`
+
+```ruby
+stub  = stub_request(:get, "www.example.com")
+stub2 = stub_request(:get, "www.example2.com")
+
+Net::HTTP.get('www.example.com', '/')
+Net::HTTP.get('www.example.com', '/')
+
+Net::HTTP.get('www.example2.com', '/')
+
+expect(stub).to have_been_requested.times(2)
+expect(stub2).to have_been_requested.times(1)
+
+WebMock.reset_executed_requests!
+
+expect(stub).not_to have_been_requested
+expect(stub2).not_to have_been_requested
+```
+
 ## Disabling and enabling WebMock or only some http client adapters
 
 ```ruby
@@ -841,6 +899,10 @@ end
 
 Please submit them here [http://github.com/bblimke/webmock/issues](http://github.com/bblimke/webmock/issues)
 
+## Issue triage [![Open Source Helpers](https://www.codetriage.com/bblimke/webmock/badges/users.svg)](https://www.codetriage.com/bblimke/webmock)
+
+You can contribute by triaging issues which may include reproducing bug reports or asking for vital information, such as version numbers or reproduction instructions. If you would like to start triaging issues, one easy way to get started is to [subscribe to webmock on CodeTriage](https://www.codetriage.com/bblimke/webmock).
+
 ## Suggestions
 
 If you have any suggestions on how to improve WebMock please send an email to the mailing list [groups.google.com/group/webmock-users](http://groups.google.com/group/webmock-users)
@@ -1035,13 +1097,86 @@ People who submitted patches and new features or suggested improvements. Many th
 * George Ulmer
 * Christof Koenig
 * Chung-Yi Chi
+* Olexandr Hoshylyk
+* Janko Marohnić
+* Pat Allan
+* Rick Song
+* NARUSE, Yui
+* Piotr Boniecki
+* Olia Kremmyda
+* Michał Matyas
+* Matt Brictson
+* Kenny Ortmann
+* redbar0n
+* Lukas Pokorny
+* Arkadiy Tetelman
+* Kazato Sugimoto
+* Olle Jonsson
+* Pavel Rosický
+* Geremia Taglialatela
+* Koichi Sasada
+* Yusuke Endoh
+* Grey Baker
+* SoonKhen OwYong
+* Pavel Valena
+* Adam Sokolnicki
+* Jeff Felchner
+* Eike Send
+* Claudio Poli
+* Csaba Apagyi
+* Frederick Cheung
+* Fábio D. Batista
+* Andriy Yanko
+* y-yagi
+* Rafael França
+* George Claghorn
+* Alex Junger
+* Orien Madgwick
+* Andrei Sidorov
+* Marco Costa
+* Ryan Davis
+* Brandur
+* Samuel Williams
+* Patrik Ragnarsson
+* Alex Coomans
+* Vesa Laakso
+* John Hawthorn
+* guppy0356
+* Thilo Rusche
+* Andrew Stuntz
+* Lucas Uyezu
+* Bruno Sutic
+* Ryan Kerr
+* Adam Harwood
+* Ben Koshy
+* Jesse Bowes
+* Marek Kasztelnik
+* ce07c3
+* Jun Jiang
+* Oleksiy Kovyrin
+* Matt Larraz
+* Tony Schneider
+* Niklas Hösl
+* Johanna Hartmann
+* Alex Vondrak
+* Will Storey
+* Eduardo Hernandez
+* ojab
+* Giorgio Gambino
+* 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/Rakefile

@@ -1,28 +1,36 @@
-#!/usr/bin/env rake
-
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
 require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec) do |t|
-  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
+  t.rspec_opts = %w[
+    --force-color
+    --format progress
+    --require ./spec/spec_helper.rb
+  ]
   t.pattern = 'spec/**/*_spec.rb'
 end
 
 RSpec::Core::RakeTask.new(:spec_http_without_webmock) do |t|
-  t.rspec_opts = ["-c", "-f progress", "-r ./spec/acceptance/net_http/real_net_http_spec.rb"]
+  t.rspec_opts = %w[
+    --force-color
+    --format progress
+    --require ./spec/acceptance/net_http/real_net_http_spec.rb
+  ]
   t.pattern = 'spec/acceptance/net_http/real_net_http_spec.rb'
 end
 
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
   test.test_files = FileList["test/**/*.rb"].exclude("test/test_helper.rb")
+  test.options = "--use-color"
   test.verbose = false
   test.warning = false
 end
 
 Rake::TestTask.new(:minitest) do |test|
   test.test_files = FileList["minitest/**/*.rb"].exclude("test/test_helper.rb")
+  test.options = "--pride"
   test.verbose = false
   test.warning = false
 end

data/lib/webmock/api.rb

@@ -54,10 +54,22 @@ module WebMock
       end
     end
 
+    def hash_excluding(*args)
+      if defined?(super)
+        super
+      else
+        WebMock::Matchers::HashExcludingMatcher.new(anythingize_lonely_keys(*args))
+      end
+    end
+
     def remove_request_stub(stub)
       WebMock::StubRegistry.instance.remove_request_stub(stub)
     end
 
+    def reset_executed_requests!
+      WebMock::RequestRegistry.instance.reset!
+    end
+
     private
 
     def convert_uri_method_and_options_to_request_and_options(method, uri, options, &block)

data/lib/webmock/http_lib_adapters/async_http_client_adapter.rb

@@ -0,0 +1,221 @@
+begin
+  require 'async'
+  require 'async/http'
+rescue LoadError
+  # async-http not found
+end
+
+if defined?(Async::HTTP)
+  module WebMock
+    module HttpLibAdapters
+      class AsyncHttpClientAdapter < HttpLibAdapter
+        adapter_for :async_http_client
+
+        OriginalAsyncHttpClient = Async::HTTP::Client unless const_defined?(:OriginalAsyncHttpClient)
+
+        class << self
+          def enable!
+            Async::HTTP.send(:remove_const, :Client)
+            Async::HTTP.send(:const_set, :Client, Async::HTTP::WebMockClientWrapper)
+          end
+
+          def disable!
+            Async::HTTP.send(:remove_const, :Client)
+            Async::HTTP.send(:const_set, :Client, OriginalAsyncHttpClient)
+          end
+        end
+      end
+    end
+  end
+
+  module Async
+    module HTTP
+      class WebMockClientWrapper < Client
+        def initialize(
+          endpoint,
+          protocol = endpoint.protocol,
+          scheme = endpoint.scheme,
+          authority = endpoint.authority,
+          **options
+        )
+          webmock_endpoint = WebMockEndpoint.new(scheme, authority, protocol)
+
+          @network_client = WebMockClient.new(endpoint, **options)
+          @webmock_client = WebMockClient.new(webmock_endpoint, **options)
+
+          @scheme = scheme
+          @authority = authority
+        end
+
+        def call(request)
+          request.scheme ||= self.scheme
+          request.authority ||= self.authority
+
+          request_signature = build_request_signature(request)
+          WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+          webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
+          net_connect_allowed = WebMock.net_connect_allowed?(request_signature.uri)
+          real_request = false
+
+          if webmock_response
+            webmock_response.raise_error_if_any
+            raise Async::TimeoutError, 'WebMock timeout error' if webmock_response.should_timeout
+            WebMockApplication.add_webmock_response(request, webmock_response)
+            response = @webmock_client.call(request)
+          elsif net_connect_allowed
+            response = @network_client.call(request)
+            real_request = true
+          else
+            raise WebMock::NetConnectNotAllowedError.new(request_signature) unless webmock_response
+          end
+
+          if WebMock::CallbackRegistry.any_callbacks?
+            webmock_response ||= build_webmock_response(response)
+            WebMock::CallbackRegistry.invoke_callbacks(
+              {
+                lib: :async_http_client,
+                real_request: real_request
+              },
+              request_signature,
+              webmock_response
+            )
+          end
+
+          response
+        end
+
+        def close
+          @network_client.close
+          @webmock_client.close
+        end
+
+        private
+
+        def build_request_signature(request)
+          body = request.read
+          request.body = ::Protocol::HTTP::Body::Buffered.wrap(body)
+          WebMock::RequestSignature.new(
+            request.method.downcase.to_sym,
+            "#{request.scheme}://#{request.authority}#{request.path}",
+            headers: request.headers.to_h,
+            body: body
+          )
+        end
+
+        def build_webmock_response(response)
+          body = response.read
+          response.body = ::Protocol::HTTP::Body::Buffered.wrap(body)
+
+          webmock_response = WebMock::Response.new
+          webmock_response.status = [
+            response.status,
+            ::Protocol::HTTP1::Reason::DESCRIPTIONS[response.status]
+          ]
+          webmock_response.headers = build_webmock_response_headers(response)
+          webmock_response.body = body
+          webmock_response
+        end
+
+        def build_webmock_response_headers(response)
+          response.headers.each.each_with_object({}) do |(k, v), o|
+            o[k] ||= []
+            o[k] << v
+          end
+        end
+      end
+
+      class WebMockClient < Client
+      end
+
+      class WebMockEndpoint
+        def initialize(scheme, authority, protocol)
+          @scheme = scheme
+          @authority = authority
+          @protocol = protocol
+        end
+
+        attr :scheme, :authority, :protocol
+
+        def connect
+          server_socket, client_socket = create_connected_sockets
+          Async(transient: true) do
+            accept_socket(server_socket)
+          end
+          client_socket
+        end
+
+        def inspect
+          "\#<#{self.class}> #{scheme}://#{authority} protocol=#{protocol}"
+        end
+
+        private
+
+        def create_connected_sockets
+          pair = begin
+            Async::IO::Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM)
+          rescue Errno::EAFNOSUPPORT
+            Async::IO::Socket.pair(Socket::AF_INET, Socket::SOCK_STREAM)
+          end
+          pair.tap do |sockets|
+            sockets.each do |socket|
+              socket.instance_variable_set :@alpn_protocol, nil
+              socket.instance_eval do
+                def alpn_protocol
+                  nil # means HTTP11 will be used for HTTPS
+                end
+              end
+            end
+          end
+        end
+
+        def accept_socket(socket)
+          server = Async::HTTP::Server.new(WebMockApplication, self)
+          server.accept(socket, socket.remote_address)
+        end
+      end
+
+      module WebMockApplication
+        WEBMOCK_REQUEST_ID_HEADER = 'x-webmock-request-id'.freeze
+
+        class << self
+          def call(request)
+            request.read
+            webmock_response = get_webmock_response(request)
+            build_response(webmock_response)
+          end
+
+          def add_webmock_response(request, webmock_response)
+            webmock_request_id = request.object_id.to_s
+            request.headers.add(WEBMOCK_REQUEST_ID_HEADER, webmock_request_id)
+            webmock_responses[webmock_request_id] = webmock_response
+          end
+
+          def get_webmock_response(request)
+            webmock_request_id = request.headers[WEBMOCK_REQUEST_ID_HEADER][0]
+            webmock_responses.fetch(webmock_request_id)
+          end
+
+          private
+
+          def webmock_responses
+            @webmock_responses ||= {}
+          end
+
+          def build_response(webmock_response)
+            headers = (webmock_response.headers || {}).each_with_object([]) do |(k, value), o|
+              Array(value).each do |v|
+                o.push [k, v]
+              end
+            end
+
+            ::Protocol::HTTP::Response[
+              webmock_response.status[0],
+              headers,
+              webmock_response.body
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/webmock/http_lib_adapters/curb_adapter.rb

@@ -5,7 +5,7 @@ rescue LoadError
 end
 
 if defined?(Curl)
-  WebMock::VersionChecker.new('Curb', Curl::CURB_VERSION, '0.7.16', '0.9.1', ['0.8.7']).check_version!
+  WebMock::VersionChecker.new('Curb', Curl::CURB_VERSION, '0.7.16', '1.0.1', ['0.8.7']).check_version!
 
   module WebMock
     module HttpLibAdapters
@@ -54,7 +54,6 @@ if defined?(Curl)
 
   module Curl
     class WebMockCurlEasy < Curl::Easy
-
       def curb_or_webmock
         request_signature = build_request_signature
         WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
@@ -129,7 +128,7 @@ if defined?(Curl)
       def headers_as_hash(headers)
         if headers.is_a?(Array)
           headers.inject({}) {|hash, header|
-            name, value = header.split(":").map(&:strip)
+            name, value = header.split(":", 2).map(&:strip)
             hash[name] = value
             hash
           }
@@ -153,7 +152,7 @@ if defined?(Curl)
         @body_str = webmock_response.body
         @response_code = webmock_response.status[0]
 
-        @header_str = "HTTP/1.1 #{webmock_response.status[0]} #{webmock_response.status[1]}\r\n"
+        @header_str = "HTTP/1.1 #{webmock_response.status[0]} #{webmock_response.status[1]}\r\n".dup
 
         @on_debug.call(@header_str, 1) if defined?( @on_debug )
 
@@ -183,7 +182,7 @@ if defined?(Curl)
         self.url = location
 
         curb_or_webmock do
-          send( "http_#{@webmock_method}_without_webmock" )
+          send( :http, {'method' => @webmock_method} )
         end
 
         self.url = first_url
@@ -271,6 +270,8 @@ if defined?(Curl)
       def perform
         @webmock_method ||= :get
         curb_or_webmock { super }
+      ensure
+        reset_webmock_method
       end
 
       def put_data= data
@@ -332,6 +333,19 @@ if defined?(Curl)
           end
         METHOD
       end
+
+      def reset_webmock_method
+        @webmock_method = :get
+      end
+
+      def reset
+        instance_variable_set(:@body_str, nil)
+        instance_variable_set(:@content_type, nil)
+        instance_variable_set(:@header_str, nil)
+        instance_variable_set(:@last_effective_url, nil)
+        instance_variable_set(:@response_code, nil)
+        super
+      end
     end
   end
 end