webmock 3.7.1

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/util/version_checker.rb

@@ -0,0 +1,111 @@
+# This code was created based on https://github.com/myronmarston/vcr/blob/master/lib/vcr/util/version_checker.rb
+# Thanks to @myronmarston
+
+# Copyright (c) 2010-2012 Myron Marston
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module WebMock
+  class VersionChecker
+    def initialize(library_name, library_version, min_patch_level, max_minor_version = nil, unsupported_versions = [])
+      @library_name, @library_version = library_name, library_version
+      @min_patch_level, @max_minor_version = min_patch_level, max_minor_version
+      @unsupported_versions = unsupported_versions || []
+
+      @major,     @minor,     @patch     = parse_version(library_version)
+      @min_major, @min_minor, @min_patch = parse_version(min_patch_level)
+      if max_minor_version
+        @max_major, @max_minor           = parse_version(max_minor_version)
+      else
+        @max_major, @max_minor           = nil, nil
+      end
+
+      @comparison_result = compare_version
+    end
+
+    def check_version!
+      warn_about_too_low if too_low?
+      warn_about_too_high if too_high?
+      warn_about_unsupported_version if unsupported_version?
+    end
+
+  private
+
+    def too_low?
+      @comparison_result == :too_low
+    end
+
+    def too_high?
+      @comparison_result == :too_high
+    end
+
+    def unsupported_version?
+      @unsupported_versions.include?(@library_version)
+    end
+
+    def warn_about_too_low
+      warn_in_red "You are using #{@library_name} #{@library_version}. " +
+                  "WebMock supports version #{version_requirement}."
+    end
+
+    def warn_about_too_high
+      warn_in_red "You are using #{@library_name} #{@library_version}. " +
+                  "WebMock is known to work with #{@library_name} #{version_requirement}. " +
+                  "It may not work with this version."
+    end
+
+    def warn_about_unsupported_version
+      warn_in_red "You are using #{@library_name} #{@library_version}. " +
+                  "WebMock does not support this version. " +
+                  "WebMock supports versions #{version_requirement}."
+    end
+
+    def warn_in_red(text)
+      Kernel.warn colorize(text, "\e[31m")
+    end
+
+    def compare_version
+      case
+        when @major < @min_major then :too_low
+        when @max_major && @major > @max_major then :too_high
+        when @major > @min_major then :ok
+        when @minor < @min_minor then :too_low
+        when @max_minor && @minor > @max_minor then :too_high
+        when @minor > @min_minor then :ok
+        when @patch < @min_patch then :too_low
+      end
+    end
+
+    def version_requirement
+      req = ">= #{@min_patch_level}"
+      req += ", < #{@max_major}.#{@max_minor + 1}" if @max_minor
+      req += ", except versions #{@unsupported_versions.join(',')}" unless @unsupported_versions.empty?
+      req
+    end
+
+    def parse_version(version)
+      version.split('.').map { |v| v.to_i }
+    end
+
+    def colorize(text, color_code)
+      "#{color_code}#{text}\e[0m"
+    end
+  end
+end

data/lib/webmock/version.rb

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

data/lib/webmock/webmock.rb

@@ -0,0 +1,161 @@
+module WebMock
+
+  def self.included(clazz)
+    WebMock::Deprecation.warning("include WebMock is deprecated. Please include WebMock::API instead")
+    if clazz.instance_methods.map(&:to_s).include?('request')
+      warn "WebMock#request was not included in #{clazz} to avoid name collision"
+    else
+      clazz.class_eval do
+        def request(method, uri)
+          WebMock::Deprecation.warning("WebMock#request is deprecated. Please use WebMock::API#a_request method instead")
+          WebMock.a_request(method, uri)
+        end
+      end
+    end
+  end
+
+  include WebMock::API
+  extend WebMock::API
+
+  class << self
+    alias :request :a_request
+  end
+
+  def self.version
+    VERSION
+  end
+
+  def self.disable!(options = {})
+    except = [options[:except]].flatten.compact
+    HttpLibAdapterRegistry.instance.each_adapter do |name, adapter|
+      adapter.enable!
+      adapter.disable! unless except.include?(name)
+    end
+  end
+
+  def self.enable!(options = {})
+    except = [options[:except]].flatten.compact
+    HttpLibAdapterRegistry.instance.each_adapter do |name, adapter|
+      adapter.disable!
+      adapter.enable! unless except.include?(name)
+    end
+  end
+
+  def self.allow_net_connect!(options = {})
+    Config.instance.allow_net_connect = true
+    Config.instance.net_http_connect_on_start = options[:net_http_connect_on_start]
+  end
+
+  def self.disable_net_connect!(options = {})
+    Config.instance.allow_net_connect = false
+    Config.instance.allow_localhost = options[:allow_localhost]
+    Config.instance.allow = options[:allow]
+    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)
+    if uri.is_a?(String)
+      uri = WebMock::Util::URI.normalize_uri(uri)
+    end
+
+    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
+
+  def self.net_connect_explicit_allowed?(allowed, uri=nil)
+    case allowed
+    when Array
+      allowed.any? { |allowed_item| net_connect_explicit_allowed?(allowed_item, uri) }
+    when Regexp
+      (uri.to_s =~ allowed) != nil ||
+      (uri.omit(:port).to_s =~ allowed) != nil && uri.port == uri.default_port
+    when String
+      allowed == uri.to_s ||
+      allowed == uri.host ||
+      allowed == "#{uri.host}:#{uri.port}" ||
+      allowed == "#{uri.scheme}://#{uri.host}:#{uri.port}" ||
+      allowed == "#{uri.scheme}://#{uri.host}" && uri.port == uri.default_port
+    else
+      if allowed.respond_to?(:call)
+        allowed.call(uri)
+      end
+    end
+  end
+
+  def self.show_body_diff!
+    Config.instance.show_body_diff = true
+  end
+
+  def self.hide_body_diff!
+    Config.instance.show_body_diff = false
+  end
+
+  def self.show_body_diff?
+    Config.instance.show_body_diff
+  end
+
+  def self.hide_stubbing_instructions!
+    Config.instance.show_stubbing_instructions = false
+  end
+
+  def self.show_stubbing_instructions!
+    Config.instance.show_stubbing_instructions = true
+  end
+
+  def self.show_stubbing_instructions?
+    Config.instance.show_stubbing_instructions
+  end
+
+  def self.reset!
+    WebMock::RequestRegistry.instance.reset!
+    WebMock::StubRegistry.instance.reset!
+  end
+
+  def self.reset_webmock
+    WebMock::Deprecation.warning("WebMock.reset_webmock is deprecated. Please use WebMock.reset! method instead")
+    reset!
+  end
+
+  def self.reset_callbacks
+    WebMock::CallbackRegistry.reset
+  end
+
+  def self.after_request(options={}, &block)
+    WebMock::CallbackRegistry.add_callback(options, block)
+  end
+
+  def self.registered_request?(request_signature)
+    WebMock::StubRegistry.instance.registered_request?(request_signature)
+  end
+
+  def self.print_executed_requests
+    puts WebMock::RequestExecutionVerifier.executed_requests_message
+  end
+
+  def self.globally_stub_request(&block)
+    WebMock::StubRegistry.instance.register_global_stub(&block)
+  end
+
+  %w(
+    allow_net_connect!
+    disable_net_connect!
+    net_connect_allowed?
+    reset_webmock
+    reset_callbacks
+    after_request
+    registered_request?
+  ).each do |method|
+    self.class_eval(%Q(
+                      def #{method}(*args, &block)
+                        WebMock::Deprecation.warning("WebMock##{method} instance method is deprecated. Please use WebMock.#{method} class method instead")
+                        WebMock.#{method}(*args, &block)
+                          end
+    ))
+  end
+end

data/minitest/test_helper.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require File.expand_path(File.dirname(__FILE__) + '/../test/http_request')
+
+gem 'minitest'
+
+require 'minitest/autorun'
+require 'webmock/minitest'
+
+test_class = defined?(MiniTest::Test) ? MiniTest::Test : MiniTest::Unit::TestCase
+
+test_class.class_eval do
+
+  def assert_raise(*exp, &block)
+    assert_raises(*exp, &block)
+  end
+
+  def assert_raise_with_message(e, message, &block)
+     e = assert_raises(e, &block)
+     if message.is_a?(Regexp)
+       assert_match(message, e.message)
+     else
+       assert_equal(message, e.message)
+     end
+   end
+
+   def assert_fail(message, &block)
+     assert_raise_with_message(MiniTest::Assertion, message, &block)
+   end
+
+end

data/minitest/test_webmock.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../test/shared_test')
+
+test_class = defined?(MiniTest::Test) ? MiniTest::Test : MiniTest::Unit::TestCase
+
+
+class MiniTestWebMock < test_class
+  include SharedTest
+end

data/minitest/webmock_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+  describe "Webmock" do
+    include HttpRequestTestHelper
+
+    before do
+      @stub_http = stub_http_request(:any, "http://www.example.com")
+      @stub_https = stub_http_request(:any, "https://www.example.com")
+    end
+
+    it "should update assertions count" do
+      assert_equal 0, assertions
+      http_request(:get, "http://www.example.com/")
+
+      assert_requested(@stub_http)
+      assert_equal 2, assertions
+
+      assert_not_requested(:post, "http://www.example.com")
+      assert_equal 4, assertions
+    end
+
+    it "should raise error on non stubbed request" do
+      lambda { http_request(:get, "http://www.example.net/") }.must_raise(WebMock::NetConnectNotAllowedError)
+    end
+
+    it "should verify that expected request occured" do
+      http_request(:get, "http://www.example.com/")
+      assert_requested(:get, "http://www.example.com", times: 1)
+      assert_requested(:get, "http://www.example.com")
+    end
+
+    it "should verify that expected http stub occured" do
+      http_request(:get, "http://www.example.com/")
+      assert_requested(@stub_http, times: 1)
+      assert_requested(@stub_http)
+    end
+
+    it "should verify that expected https stub occured" do
+      http_request(:get, "https://www.example.com/")
+      http_request(:get, "https://www.example.com/")
+      assert_requested(@stub_https, times: 2)
+    end
+
+    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============================================================"
+     assert_fail(expected_message) do
+       assert_requested(:get, "http://www.example.com")
+     end
+    end
+
+    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============================================================"
+     assert_fail(expected_message) do
+       assert_requested(@stub_http)
+     end
+    end
+  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