webmock 3.0.0 → 3.14.0

data/lib/webmock/util/uri.rb

@@ -33,7 +33,7 @@ module WebMock
         NORMALIZED_URIS[uri].dup
       end
 
-      def self.variations_of_uri_as_strings(uri_object)
+      def self.variations_of_uri_as_strings(uri_object, only_with_scheme: false)
         normalized_uri = normalize_uri(uri_object.dup).freeze
         uris = [ normalized_uri ]
 
@@ -41,13 +41,13 @@ module WebMock
           uris = uris_with_trailing_slash_and_without(uris)
         end
 
-        uris = uris_encoded_and_unencoded(uris)
-
         if normalized_uri.port == Addressable::URI.port_mapping[normalized_uri.scheme]
           uris = uris_with_inferred_port_and_without(uris)
         end
 
-        if normalized_uri.scheme == "http"
+        uris = uris_encoded_and_unencoded(uris)
+
+        if normalized_uri.scheme == "http" && !only_with_scheme
           uris = uris_with_scheme_and_without(uris)
         end
 
@@ -80,27 +80,27 @@ module WebMock
 
       def self.uris_with_inferred_port_and_without(uris)
         uris.map { |uri|
-          uri = uri.dup.force_encoding(Encoding::ASCII_8BIT) if uri.respond_to?(:force_encoding)
-          [ uri, uri.gsub(%r{(:80)|(:443)}, "").freeze ]
+          [ uri, uri.omit(:port)]
         }.flatten
       end
 
       def self.uris_encoded_and_unencoded(uris)
         uris.map do |uri|
-          [ uri.to_s, Addressable::URI.unencode(uri, String).freeze ]
+          [
+            uri.to_s.force_encoding(Encoding::ASCII_8BIT),
+            Addressable::URI.unencode(uri, String).force_encoding(Encoding::ASCII_8BIT).freeze
+          ]
         end.flatten
       end
 
       def self.uris_with_scheme_and_without(uris)
         uris.map { |uri|
-          uri = uri.dup.force_encoding(Encoding::ASCII_8BIT) if uri.respond_to?(:force_encoding)
           [ uri, uri.gsub(%r{^https?://},"").freeze ]
         }.flatten
       end
 
       def self.uris_with_trailing_slash_and_without(uris)
-        uris = uris.map { |uri|
-          uri = uri.dup.force_encoding(Encoding::ASCII_8BIT) if uri.respond_to?(:force_encoding)
+        uris.map { |uri|
           [ uri, uri.omit(:path).freeze ]
         }.flatten
       end

data/lib/webmock/util/values_stringifier.rb

@@ -0,0 +1,20 @@
+class WebMock::Util::ValuesStringifier
+  def self.stringify_values(value)
+    case value
+    when String, Numeric, TrueClass, FalseClass
+      value.to_s
+    when Hash
+      Hash[
+        value.map do |k, v|
+          [k, stringify_values(v)]
+        end
+      ]
+    when Array
+      value.map do |v|
+        stringify_values(v)
+      end
+    else
+      value
+    end
+  end
+end

data/lib/webmock/version.rb

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

data/lib/webmock/webmock.rb

@@ -53,12 +53,19 @@ module WebMock
     Config.instance.net_http_connect_on_start = options[:net_http_connect_on_start]
   end
 
+  class << self
+    alias :enable_net_connect!   :allow_net_connect!
+    alias :disallow_net_connect! :disable_net_connect!
+  end
+
   def self.net_connect_allowed?(uri = nil)
+    return !!Config.instance.allow_net_connect if uri.nil?
+
     if uri.is_a?(String)
       uri = WebMock::Util::URI.normalize_uri(uri)
     end
 
-    Config.instance.allow_net_connect ||
+    !!Config.instance.allow_net_connect ||
     ( Config.instance.allow_localhost && WebMock::Util::URI.is_uri_localhost?(uri) ||
       Config.instance.allow && net_connect_explicit_allowed?(Config.instance.allow, uri) )
   end
@@ -133,8 +140,8 @@ module WebMock
     puts WebMock::RequestExecutionVerifier.executed_requests_message
   end
 
-  def self.globally_stub_request(&block)
-    WebMock::StubRegistry.instance.register_global_stub(&block)
+  def self.globally_stub_request(order = :before_local_stubs, &block)
+    WebMock::StubRegistry.instance.register_global_stub(order, &block)
   end
 
   %w(

data/lib/webmock.rb

@@ -4,51 +4,56 @@ require 'addressable/uri'
 require 'addressable/template'
 require 'crack/xml'
 
-require 'webmock/deprecation'
-require 'webmock/version'
-
-require 'webmock/errors'
-
-require 'webmock/util/query_mapper'
-require 'webmock/util/uri'
-require 'webmock/util/headers'
-require 'webmock/util/hash_counter'
-require 'webmock/util/hash_keys_stringifier'
-require 'webmock/util/json'
-require 'webmock/util/version_checker'
-require 'webmock/util/hash_validator'
-
-require 'webmock/matchers/hash_including_matcher'
-
-require 'webmock/request_pattern'
-require 'webmock/request_signature'
-require 'webmock/responses_sequence'
-require 'webmock/request_stub'
-require 'webmock/response'
-require 'webmock/rack_response'
-
-require 'webmock/stub_request_snippet'
-require 'webmock/request_signature_snippet'
-require 'webmock/request_body_diff'
-
-require 'webmock/assertion_failure'
-require 'webmock/request_execution_verifier'
-require 'webmock/config'
-require 'webmock/callback_registry'
-require 'webmock/request_registry'
-require 'webmock/stub_registry'
-require 'webmock/api'
-
-require 'webmock/http_lib_adapters/http_lib_adapter_registry'
-require 'webmock/http_lib_adapters/http_lib_adapter'
-require 'webmock/http_lib_adapters/net_http'
-require 'webmock/http_lib_adapters/http_rb_adapter'
-require 'webmock/http_lib_adapters/httpclient_adapter'
-require 'webmock/http_lib_adapters/patron_adapter'
-require 'webmock/http_lib_adapters/curb_adapter'
-require 'webmock/http_lib_adapters/em_http_request_adapter'
-require 'webmock/http_lib_adapters/typhoeus_hydra_adapter'
-require 'webmock/http_lib_adapters/excon_adapter'
-require 'webmock/http_lib_adapters/manticore_adapter'
-
-require 'webmock/webmock'
+require_relative 'webmock/deprecation'
+require_relative 'webmock/version'
+
+require_relative 'webmock/errors'
+
+require_relative 'webmock/util/query_mapper'
+require_relative 'webmock/util/uri'
+require_relative 'webmock/util/headers'
+require_relative 'webmock/util/hash_counter'
+require_relative 'webmock/util/hash_keys_stringifier'
+require_relative 'webmock/util/values_stringifier'
+require_relative 'webmock/util/json'
+require_relative 'webmock/util/version_checker'
+require_relative 'webmock/util/hash_validator'
+
+require_relative 'webmock/matchers/hash_argument_matcher'
+require_relative 'webmock/matchers/hash_excluding_matcher'
+require_relative 'webmock/matchers/hash_including_matcher'
+require_relative 'webmock/matchers/any_arg_matcher'
+
+require_relative 'webmock/request_pattern'
+require_relative 'webmock/request_signature'
+require_relative 'webmock/responses_sequence'
+require_relative 'webmock/request_stub'
+require_relative 'webmock/response'
+require_relative 'webmock/rack_response'
+
+require_relative 'webmock/stub_request_snippet'
+require_relative 'webmock/request_signature_snippet'
+require_relative 'webmock/request_body_diff'
+
+require_relative 'webmock/assertion_failure'
+require_relative 'webmock/request_execution_verifier'
+require_relative 'webmock/config'
+require_relative 'webmock/callback_registry'
+require_relative 'webmock/request_registry'
+require_relative 'webmock/stub_registry'
+require_relative 'webmock/api'
+
+require_relative 'webmock/http_lib_adapters/http_lib_adapter_registry'
+require_relative 'webmock/http_lib_adapters/http_lib_adapter'
+require_relative 'webmock/http_lib_adapters/net_http'
+require_relative 'webmock/http_lib_adapters/http_rb_adapter'
+require_relative 'webmock/http_lib_adapters/httpclient_adapter'
+require_relative 'webmock/http_lib_adapters/patron_adapter'
+require_relative 'webmock/http_lib_adapters/curb_adapter'
+require_relative 'webmock/http_lib_adapters/em_http_request_adapter'
+require_relative 'webmock/http_lib_adapters/typhoeus_hydra_adapter'
+require_relative 'webmock/http_lib_adapters/excon_adapter'
+require_relative 'webmock/http_lib_adapters/manticore_adapter'
+require_relative 'webmock/http_lib_adapters/async_http_client_adapter'
+
+require_relative 'webmock/webmock'

data/minitest/webmock_spec.rb

@@ -43,7 +43,7 @@ require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 
     it  "should verify that expect request didn't occur" do
      expected_message = "The request GET http://www.example.com/ was expected to execute 1 time but it executed 0 times"
-     expected_message << "\n\nThe following requests were made:\n\nNo requests were made.\n============================================================"
+     expected_message += "\n\nThe following requests were made:\n\nNo requests were made.\n============================================================"
      assert_fail(expected_message) do
        assert_requested(:get, "http://www.example.com")
      end
@@ -51,7 +51,7 @@ require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 
     it  "should verify that expect stub didn't occur" do
      expected_message = "The request ANY http://www.example.com/ was expected to execute 1 time but it executed 0 times"
-     expected_message << "\n\nThe following requests were made:\n\nNo requests were made.\n============================================================"
+     expected_message += "\n\nThe following requests were made:\n\nNo requests were made.\n============================================================"
      assert_fail(expected_message) do
        assert_requested(@stub_http)
      end

data/spec/acceptance/async_http_client/async_http_client_spec.rb

@@ -0,0 +1,375 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'acceptance/webmock_shared'
+require_relative './async_http_client_spec_helper'
+
+require 'protocol/http/body/file'
+
+Async.logger.debug! if ENV['ASYNC_LOGGER_DEBUG']
+
+unless RUBY_PLATFORM =~ /java/
+  describe 'Async::HTTP::Client' do
+    include AsyncHttpClientSpecHelper
+
+    include_context "with WebMock",
+      :no_status_message,
+      :no_url_auth,
+      :no_content_length_header
+
+    it 'works' do
+      stub_request(:get, 'http://www.example.com')
+      expect(make_request(:get, 'http://www.example.com')).to eq(
+        status: 200,
+        headers: {},
+        body: nil
+      )
+    end
+
+    it 'works with request path' do
+      stub_request(:get, 'http://www.example.com/foo')
+      expect(make_request(:get, 'http://www.example.com/foo')).to eq(
+        status: 200,
+        headers: {},
+        body: nil
+      )
+    end
+
+    it 'works with request query' do
+      stub_request(:get, 'http://www.example.com/').with(
+        query: {
+          'foo' => 'bar'
+        }
+      )
+      expect(make_request(:get, 'http://www.example.com/?foo=bar')).to eq(
+        status: 200,
+        headers: {},
+        body: nil
+      )
+    end
+
+    it 'works with request headers' do
+      stub_request(:get, 'http://www.example.com').with(
+        headers: {
+          'X-Token' => 'Token'
+        }
+      )
+      expect(
+        make_request :get, 'http://www.example.com',
+          headers: {
+            'X-Token' => 'Token'
+        }
+      ).to eq(
+        status: 200,
+        headers: {},
+        body: nil
+      )
+    end
+
+    it 'works with request body as text' do
+      stub_request(:post, 'http://www.example.com').with(
+        body: 'x'*10_000
+      )
+      expect(
+        make_request :post, 'http://www.example.com',
+          body: 'x'*10_000
+      ).to eq(
+        status: 200,
+        headers: {},
+        body: nil
+      )
+    end
+
+    it 'works with request body as file' do
+      stub_request(:post, "www.example.com").with(
+        body: File.read(__FILE__)
+      )
+      expect(
+        make_request :post, "http://www.example.com",
+          body: ::Protocol::HTTP::Body::File.open(__FILE__, block_size: 32)
+      ).to eq(
+        status: 200,
+        headers: {},
+        body: nil
+      )
+    end
+
+    it 'works with response status' do
+      stub_request(:get, 'http://www.example.com').to_return(
+        status: 400
+      )
+      expect(make_request(:get, 'http://www.example.com')).to eq(
+        status: 400,
+        headers: {},
+        body: nil
+      )
+    end
+
+    it 'works with response headers' do
+      stub_request(:get, 'http://www.example.com').to_return(
+        headers: {
+          'X-Token' => 'TOKEN'
+        }
+      )
+      expect(make_request(:get, 'http://www.example.com')).to eq(
+        status: 200,
+        headers: {
+          'x-token' => ['TOKEN']
+        },
+        body: nil
+      )
+    end
+
+    it 'works with response body' do
+      stub_request(:get, 'http://www.example.com').to_return(
+        body: 'abc'
+      )
+      expect(make_request(:get, 'http://www.example.com')).to eq(
+        status: 200,
+        headers: {},
+        body: 'abc'
+      )
+    end
+
+    it 'works with to_timeout' do
+      stub_request(:get, 'http://www.example.com').to_timeout
+      expect { make_request(:get, 'http://www.example.com') }.to raise_error Async::TimeoutError
+    end
+
+    it 'does not invoke "after real request" callbacks for stubbed requests' do
+      WebMock.allow_net_connect!
+      stub_request(:get, 'http://www.example.com').to_return(body: 'abc')
+
+      callback_invoked = false
+      WebMock.after_request(real_requests_only: true) { |_| callback_invoked = true }
+
+      make_request(:get, 'http://www.example.com')
+      expect(callback_invoked).to eq(false)
+    end
+
+    it 'does invoke "after request" callbacks for stubbed requests' do
+      WebMock.allow_net_connect!
+      stub_request(:get, 'http://www.example.com').to_return(body: 'abc')
+
+      callback_invoked = false
+      WebMock.after_request(real_requests_only: false) { |_| callback_invoked = true }
+
+      make_request(:get, 'http://www.example.com')
+      expect(callback_invoked).to eq(true)
+    end
+
+    context 'scheme and protocol' do
+      let(:default_response_headers) { {} }
+
+      before do
+        stub_request(
+          :get, "#{scheme}://www.example.com"
+        ).and_return(
+          body: 'BODY'
+        )
+      end
+
+      subject do
+        make_request(:get, "#{scheme}://www.example.com", protocol: protocol)
+      end
+
+      shared_examples :common do
+        specify do
+          expect(subject).to eq(
+            status: 200,
+            headers: default_response_headers,
+            body: 'BODY'
+          )
+        end
+      end
+
+      context 'http scheme' do
+        let(:scheme) { 'http' }
+
+        context 'default protocol' do
+          let(:protocol) { nil }
+
+          include_examples :common
+        end
+
+        context 'HTTP10 protocol' do
+          let(:protocol) { Async::HTTP::Protocol::HTTP10 }
+          let(:default_response_headers) { {"connection"=>["keep-alive"]} }
+
+          include_examples :common
+        end
+
+        context 'HTTP11 protocol' do
+          let(:protocol) { Async::HTTP::Protocol::HTTP11 }
+
+          include_examples :common
+        end
+
+        context 'HTTP2 protocol' do
+          let(:protocol) { Async::HTTP::Protocol::HTTP2 }
+
+          include_examples :common
+        end
+      end
+
+      context 'https scheme' do
+        let(:scheme) { 'https' }
+
+        context 'default protocol' do
+          let(:protocol) { nil }
+
+          include_examples :common
+        end
+
+        context 'HTTP10 protocol' do
+          let(:protocol) { Async::HTTP::Protocol::HTTP10 }
+          let(:default_response_headers) { {"connection"=>["keep-alive"]} }
+
+          include_examples :common
+        end
+
+        context 'HTTP11 protocol' do
+          let(:protocol) { Async::HTTP::Protocol::HTTP11 }
+
+          include_examples :common
+        end
+
+        context 'HTTP2 protocol' do
+          let(:protocol) { Async::HTTP::Protocol::HTTP2 }
+
+          include_examples :common
+        end
+
+        context 'HTTPS protocol' do
+          let(:protocol) { Async::HTTP::Protocol::HTTPS }
+
+          include_examples :common
+        end
+      end
+    end
+
+    context 'multiple requests' do
+      let(:endpoint) { Async::HTTP::Endpoint.parse('http://www.example.com') }
+      let(:requests_count) { 3 }
+
+      shared_examples :common do
+        before do
+          requests_count.times do |index|
+            stub_request(
+              :get, "http://www.example.com/foo#{index}"
+            ).to_return(
+              status: 200 + index,
+              headers: {'X-Token' => "foo#{index}"},
+              body: "FOO#{index}"
+            )
+          end
+        end
+
+       specify do
+         expect(subject).to eq(
+           0 => {
+             status: 200,
+             headers: {'x-token' => ['foo0']},
+             body: 'FOO0'
+           },
+           1 => {
+             status: 201,
+             headers: {'x-token' => ['foo1']},
+             body: 'FOO1'
+           },
+           2 => {
+             status: 202,
+             headers: {'x-token' => ['foo2']},
+             body: 'FOO2'
+           }
+         )
+       end
+      end
+
+      context 'sequential' do
+        subject do
+          responses = {}
+          Async do |task|
+            Async::HTTP::Client.open(endpoint, protocol) do |client|
+              requests_count.times do |index|
+                response = client.get "/foo#{index}"
+                responses[index] = response_to_hash(response)
+              end
+            end
+          end
+          responses
+        end
+
+        context 'HTTP1 protocol' do
+          let(:protocol) { Async::HTTP::Protocol::HTTP1 }
+
+          include_examples :common
+        end
+
+        context 'HTTP2 protocol' do
+          let(:protocol) { Async::HTTP::Protocol::HTTP2 }
+
+          include_examples :common
+        end
+      end
+
+      context 'asynchronous' do
+        subject do
+          responses = {}
+          Async do |task|
+            Async::HTTP::Client.open(endpoint, protocol) do |client|
+              tasks = requests_count.times.map do |index|
+                task.async do
+                  response = client.get "/foo#{index}"
+                  responses[index] = response_to_hash(response)
+                end
+              end
+
+              tasks.map(&:wait)
+            end
+          end
+          responses
+        end
+
+        context 'HTTP1 protocol' do
+          let(:protocol) { Async::HTTP::Protocol::HTTP1 }
+
+          include_examples :common
+        end
+
+        context 'HTTP2 protocol' do
+          let(:protocol) { Async::HTTP::Protocol::HTTP2 }
+
+          include_examples :common
+        end
+      end
+    end
+
+    def make_request(method, url, protocol: nil, headers: {}, body: nil)
+      Async do
+        endpoint = Async::HTTP::Endpoint.parse(url)
+
+        begin
+          Async::HTTP::Client.open(endpoint, protocol || endpoint.protocol) do |client|
+            response = client.send(
+              method,
+              endpoint.path,
+              headers,
+              body
+            )
+            response_to_hash(response)
+          end
+        rescue Async::TimeoutError => e
+          e
+        end
+      end.wait
+    end
+
+    def response_to_hash(response)
+      {
+        status: response.status,
+        headers: response.headers.to_h,
+        body: response.read
+      }
+    end
+  end
+end

data/spec/acceptance/async_http_client/async_http_client_spec_helper.rb

@@ -0,0 +1,73 @@
+module AsyncHttpClientSpecHelper
+  def http_request(method, url, options = {}, &block)
+    endpoint = Async::HTTP::Endpoint.parse(url)
+
+    path = endpoint.path
+    path = path + "?" + options[:query] if options[:query]
+
+    headers = (options[:headers] || {}).each_with_object([]) do |(k, v), o|
+      Array(v).each do |v|
+        o.push [k, v]
+      end
+    end
+    headers.push(
+      ['authorization', 'Basic ' + Base64.strict_encode64(options[:basic_auth].join(':'))]
+    ) if options[:basic_auth]
+
+    body = options[:body]
+
+    Async do
+      begin
+        Async::HTTP::Client.open(endpoint) do |client|
+          response = client.send(
+            method,
+            path,
+            headers,
+            body
+          )
+
+          OpenStruct.new(
+            build_hash_response(response)
+          )
+        end
+      rescue Exception => e
+        e
+      end
+    end.wait
+  end
+
+  def client_timeout_exception_class
+    Async::TimeoutError
+  end
+
+  def connection_refused_exception_class
+    Errno::ECONNREFUSED
+  end
+
+  def http_library
+    :async_http_client
+  end
+
+  private
+
+  def build_hash_response(response)
+    {
+
+      status: response.status.to_s,
+      message: Protocol::HTTP1::Reason::DESCRIPTIONS[response.status],
+      headers: build_response_headers(response),
+      body: response.read
+    }
+  end
+
+  def build_response_headers(response)
+    response.headers.each.each_with_object({}) do |(k, v), o|
+      o[k] ||= []
+      o[k] << v
+    end.tap do |o|
+      o.each do |k, v|
+        o[k] = v.join(', ')
+      end
+    end
+  end
+end