webmock 3.6.2 → 3.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d54455d6752d60f630b108721f21ad51f4d2e648cf1fe492f72cce5d0e3bd66
-  data.tar.gz: 937d29ecd33fe244fe5f9749140d94c4ea68134b8afdcdd44a4ec41d5562df10
+  metadata.gz: 95babf82ad860e3ab49c323e66fcc785820dfecf100c03aa2fc126329e35c64a
+  data.tar.gz: 36d86569a52f5a999d9d2093a05a09fde833aaa669d94b94325ca11f03479027
 SHA512:
-  metadata.gz: 46ffed006b40f5d04d66ca5c3997f5874801e55d50a6580c1f3686a1c06a2fd4f69b4ab23c07f4828bdf01ace8749a0a7874a92db04780e621333a731bf89baf
-  data.tar.gz: 3d265897b59b5adcf8cf1954c5656160eb8bfeeb583d3abdcf9883b61b88b1b09ed050da8f45f582a190a86beb8d1bb809d55b39d89ac9ab4ed1681bc05ebeaa
+  metadata.gz: 34a48904414979c39edd9ee796172ea6a2018392b9a3a6e9ef28fc47b550e542f83c247382206e0d13fe51df8becd008f6b4e135976f7f08b3088fe13f680670
+  data.tar.gz: bb1a6e478680c68f109a0937f7b372a08e3f2a0385fa79386acae1ed5db35b679224376b62258472dcf55b66386166a8dcbf9c1580beb16938e439816f475873

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 3.7.2
+
+  * Fixed handling of non UTF-8 encoded urls
+
+    Thanks to [Rafael França](https://github.com/rafaelfranca)
+
+  * Fixed "shadowing outer local variable" warning
+
+    Thanks to [y-yagi](https://github.com/y-yagi)
+
+## 3.7.1
+
+  * Fixed Async::HTTP::Client adapter code to not cause Ruby warning
+
+    Thanks to [y-yagi](https://github.com/y-yagi)
+
+## 3.7.0
+
+  * Support for Async::HTTP::Client
+
+    Thanks to [Andriy Yanko](https://github.com/ayanko)
+
 ## 3.6.2
 
   * Fixed Patron adapter to handle HTTP/2 status line.

data/README.md

@@ -33,6 +33,7 @@ Supported HTTP libraries
 * Excon
 * HTTP Gem
 * Manticore
+* Async::HTTP::Client
 
 Supported Ruby Interpreters
 ---------------------------
@@ -1105,8 +1106,9 @@ People who submitted patches and new features or suggested improvements. Many th
 * Csaba Apagyi
 * Frederick Cheung
 * Fábio D. Batista
-
-
+* Andriy Yanko
+* y-yagi
+* Rafael França
 
 
 For a full list of contributors you can visit the

data/lib/webmock.rb

@@ -54,5 +54,6 @@ 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/lib/webmock/http_lib_adapters/async_http_client_adapter.rb

@@ -0,0 +1,214 @@
+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, protocol, scheme, authority, options)
+          @webmock_client = WebMockClient.new(webmock_endpoint, protocol, scheme, authority, 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)
+
+          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)
+          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: net_connect_allowed
+              },
+              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 do
+            accept_socket(server_socket)
+          end
+          client_socket
+        end
+
+        def inspect
+          "\#<#{self.class}> #{scheme}://#{authority} protocol=#{protocol}"
+        end
+
+        private
+
+        def create_connected_sockets
+          Async::IO::Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM).tap do |sockets|
+            sockets.each do |socket|
+              socket.instance_variable_set :@alpn_protocol, @alpn_protocol
+              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/em_http_request_adapter.rb

@@ -107,7 +107,7 @@ if defined?(EventMachine::HttpClient)
           @uri ||= nil
           EM.next_tick {
             setup(make_raw_response(stubbed_webmock_response), @uri,
-                  stubbed_webmock_response.should_timeout ? "WebMock timeout error" : nil)
+                  stubbed_webmock_response.should_timeout ? Errno::ETIMEDOUT : nil)
           }
           self
         elsif WebMock.net_connect_allowed?(request_signature.uri)

data/lib/webmock/util/uri.rb

@@ -86,20 +86,21 @@ module WebMock
 
       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/version.rb

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

data/spec/acceptance/async_http_client/async_http_client_spec.rb

@@ -0,0 +1,349 @@
+# 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
+
+    context 'scheme and protocol' do
+      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: {},
+            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 }
+
+          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 }
+
+          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

data/spec/acceptance/em_http_request/em_http_request_spec_helper.rb

@@ -50,7 +50,7 @@ module EMHttpRequestSpecHelper
   end
 
   def client_timeout_exception_class
-    "WebMock timeout error"
+    'Errno::ETIMEDOUT'
   end
 
   def connection_refused_exception_class

data/spec/acceptance/shared/callbacks.rb

@@ -111,7 +111,8 @@ shared_context "callbacks" do |*adapter_info|
         end
 
         it "should pass real response to callback with headers" do
-          expect(@response.headers["Content-Length"]).to eq("11")
+          expect(@response.headers["X-Powered-By"]).to eq( "ASP.NET")
+          expect(@response.headers["Content-Length"]).to eq("11") unless adapter_info.include?(:no_content_length_header)
         end
 
         it "should pass response to callback with body" do

data/spec/acceptance/shared/returning_declared_responses.rb

@@ -64,7 +64,10 @@ shared_context "declared responses" do |*adapter_info|
     it "should return response with declared headers" do
       stub_request(:get, "www.example.com").to_return(headers: SAMPLE_HEADERS)
       response = http_request(:get, "http://www.example.com/")
-      expect(response.headers["Content-Length"]).to eq("8888")
+      expect(response.headers["Accept"]).to eq("application/json")
+      unless adapter_info.include?(:no_content_length_header)
+        expect(response.headers["Content-Length"]).to eq("8888")
+      end
     end
 
     it "should return response with declared headers even if there are multiple headers with the same key" do
@@ -171,13 +174,22 @@ shared_context "declared responses" do |*adapter_info|
       end
 
       it "should return recorded 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"
-        })
+        if adapter_info.include?(:no_content_length_header)
+          expect(@response.headers).to eq({
+            "Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
+            "Content-Type"=>"text/html; charset=UTF-8",
+            "Connection"=>"Keep-Alive",
+            "Accept"=>"image/jpeg, image/png"
+          })
+        else
+          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
       end
 
       it "should return recorded body" do
@@ -205,13 +217,22 @@ shared_context "declared responses" do |*adapter_info|
       end
 
       it "should return recorded 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"
-        })
+        if adapter_info.include?(:no_content_length_header)
+          expect(@response.headers).to eq({
+            "Date"=>"Sat, 23 Jan 2010 01:01:05 GMT",
+            "Content-Type"=>"text/html; charset=UTF-8",
+            "Connection"=>"Keep-Alive",
+            "Accept"=>"image/jpeg, image/png"
+          })
+        else
+          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
       end
 
       it "should return recorded body" do

data/spec/unit/util/uri_spec.rb

@@ -177,6 +177,16 @@ describe WebMock::Util::URI do
       end
     end
 
+    it "should find all variations of uris with https, basic auth, a non-standard port and a path" do
+      uri = "https://~%8A:pass@www.example.com:9000/foo"
+      variations = [
+        "https://~%8A:pass@www.example.com:9000/foo",
+        "https://~\x8A:pass@www.example.com:9000/foo".force_encoding(Encoding::ASCII_8BIT)
+      ]
+
+      expect(WebMock::Util::URI.variations_of_uri_as_strings(uri)).to eq(variations)
+    end
+
   end
 
   describe "normalized uri equality" do

data/webmock.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'em-http-request', '>= 1.0.2'
   s.add_development_dependency 'em-synchrony',    '>= 1.0.0'
   s.add_development_dependency 'excon',           '>= 0.27.5'
+  s.add_development_dependency 'async-http',      '>= 0.48.0'
   s.add_development_dependency 'minitest',        '>= 5.0.0'
   s.add_development_dependency 'test-unit',       '>= 3.0.0'
   s.add_development_dependency 'rdoc',            '>  3.5.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: webmock
 version: !ruby/object:Gem::Version
-  version: 3.6.2
+  version: 3.7.2
 platform: ruby
 authors:
 - Bartosz Blimke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-31 00:00:00.000000000 Z
+date: 2019-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -198,6 +198,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.27.5
+- !ruby/object:Gem::Dependency
+  name: async-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.48.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.48.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -265,6 +279,7 @@ files:
 - lib/webmock/cucumber.rb
 - lib/webmock/deprecation.rb
 - lib/webmock/errors.rb
+- lib/webmock/http_lib_adapters/async_http_client_adapter.rb
 - lib/webmock/http_lib_adapters/curb_adapter.rb
 - lib/webmock/http_lib_adapters/em_http_request_adapter.rb
 - lib/webmock/http_lib_adapters/excon_adapter.rb
@@ -318,6 +333,8 @@ files:
 - minitest/test_helper.rb
 - minitest/test_webmock.rb
 - minitest/webmock_spec.rb
+- spec/acceptance/async_http_client/async_http_client_spec.rb
+- spec/acceptance/async_http_client/async_http_client_spec_helper.rb
 - spec/acceptance/curb/curb_spec.rb
 - spec/acceptance/curb/curb_spec_helper.rb
 - spec/acceptance/em_http_request/em_http_request_spec.rb
@@ -409,6 +426,8 @@ signing_key:
 specification_version: 4
 summary: Library for stubbing HTTP requests in Ruby.
 test_files:
+- spec/acceptance/async_http_client/async_http_client_spec.rb
+- spec/acceptance/async_http_client/async_http_client_spec_helper.rb
 - spec/acceptance/curb/curb_spec.rb
 - spec/acceptance/curb/curb_spec_helper.rb
 - spec/acceptance/em_http_request/em_http_request_spec.rb