webmock 3.5.1 → 3.11.0

data/lib/webmock/version.rb

@@ -1,3 +1,3 @@
 module WebMock
-  VERSION = '3.5.1' unless defined?(::WebMock::VERSION)
+  VERSION = '3.11.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/spec/acceptance/async_http_client/async_http_client_spec.rb

@@ -0,0 +1,353 @@
+# 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
+      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