webmock 1.8.6 → 3.14.0

data/lib/webmock.rb

@@ -1,49 +1,59 @@
 require 'singleton'
 
 require 'addressable/uri'
-require 'crack'
-
-require 'webmock/deprecation'
-require 'webmock/version'
-
-require 'webmock/errors'
-
-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/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/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/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/webmock'
-
-
+require 'addressable/template'
+require 'crack/xml'
+
+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/test_helper.rb

@@ -5,11 +5,15 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require File.expand_path(File.dirname(__FILE__) + '/../test/http_request')
 
-gem "minitest"
+gem 'minitest'
+
 require 'minitest/autorun'
 require 'webmock/minitest'
 
-class MiniTest::Unit::TestCase
+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
@@ -26,4 +30,5 @@ class MiniTest::Unit::TestCase
    def assert_fail(message, &block)
      assert_raise_with_message(MiniTest::Assertion, message, &block)
    end
-end
+
+end

data/minitest/test_webmock.rb

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

data/minitest/webmock_spec.rb

@@ -8,31 +8,42 @@ require File.expand_path(File.dirname(__FILE__) + '/test_helper')
       @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", 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, 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)
+      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============================================================"
+     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
@@ -40,11 +51,10 @@ 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
     end
-
   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