webmock 3.7.1

data/lib/webmock/http_lib_adapters/net_http_response.rb

@@ -0,0 +1,34 @@
+# This code is entierly copied from VCR (http://github.com/myronmarston/vcr) by courtesy of Myron Marston
+
+# A Net::HTTP response that has already been read raises an IOError when #read_body
+# is called with a destination string or block.
+#
+# This causes a problem when VCR records a response--it reads the body before yielding
+# the response, and if the code that is consuming the HTTP requests uses #read_body, it
+# can cause an error.
+#
+# This is a bit of a hack, but it allows a Net::HTTP response to be "re-read"
+# after it has aleady been read.  This attemps to preserve the behavior of
+# #read_body, acting just as if it had never been read.
+
+
+module Net
+  module WebMockHTTPResponse
+    def read_body(dest = nil, &block)
+      if !(defined?(@__read_body_previously_called).nil?) && @__read_body_previously_called
+        return super
+      end
+      return @body if dest.nil? && block.nil?
+      raise ArgumentError.new("both arg and block given for HTTP method") if dest && block
+      return nil if @body.nil?
+
+      dest ||= ::Net::ReadAdapter.new(block)
+      dest << @body.dup
+      @body = dest
+    ensure
+      # allow subsequent calls to #read_body to proceed as normal, without our hack...
+      @__read_body_previously_called = true
+    end
+  end
+end
+

data/lib/webmock/http_lib_adapters/patron_adapter.rb

@@ -0,0 +1,130 @@
+begin
+  require 'patron'
+rescue LoadError
+  # patron not found
+end
+
+if defined?(::Patron)
+  module WebMock
+    module HttpLibAdapters
+      class PatronAdapter < ::WebMock::HttpLibAdapter
+        adapter_for :patron
+
+        OriginalPatronSession = ::Patron::Session unless const_defined?(:OriginalPatronSession)
+
+        class WebMockPatronSession < ::Patron::Session
+          def handle_request(req)
+            request_signature =
+              WebMock::HttpLibAdapters::PatronAdapter.build_request_signature(req)
+
+            WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+            if webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
+              WebMock::HttpLibAdapters::PatronAdapter.
+                handle_file_name(req, webmock_response)
+              res = WebMock::HttpLibAdapters::PatronAdapter.
+                build_patron_response(webmock_response, default_response_charset)
+              WebMock::CallbackRegistry.invoke_callbacks(
+                {lib: :patron}, request_signature, webmock_response)
+              res
+            elsif WebMock.net_connect_allowed?(request_signature.uri)
+              res = super
+              if WebMock::CallbackRegistry.any_callbacks?
+                webmock_response = WebMock::HttpLibAdapters::PatronAdapter.
+                  build_webmock_response(res)
+                WebMock::CallbackRegistry.invoke_callbacks(
+                  {lib: :patron, real_request: true}, request_signature,
+                    webmock_response)
+              end
+              res
+            else
+              raise WebMock::NetConnectNotAllowedError.new(request_signature)
+            end
+          end
+        end
+
+        def self.enable!
+          Patron.send(:remove_const, :Session)
+          Patron.send(:const_set, :Session, WebMockPatronSession)
+        end
+
+        def self.disable!
+          Patron.send(:remove_const, :Session)
+          Patron.send(:const_set, :Session, OriginalPatronSession)
+        end
+
+        def self.handle_file_name(req, webmock_response)
+          if req.action == :get && req.file_name
+            begin
+              File.open(req.file_name, "w") do |f|
+                f.write webmock_response.body
+              end
+            rescue Errno::EACCES
+              raise ArgumentError.new("Unable to open specified file.")
+            end
+          end
+        end
+
+        def self.build_request_signature(req)
+          uri = WebMock::Util::URI.heuristic_parse(req.url)
+          uri.path = uri.normalized_path.gsub("[^:]//","/")
+
+          if [:put, :post, :patch].include?(req.action)
+            if req.file_name
+              if !File.exist?(req.file_name) || !File.readable?(req.file_name)
+                raise ArgumentError.new("Unable to open specified file.")
+              end
+              request_body = File.read(req.file_name)
+            elsif req.upload_data
+              request_body = req.upload_data
+            else
+              raise ArgumentError.new("Must provide either data or a filename when doing a PUT or POST")
+            end
+          end
+
+          headers = req.headers
+
+          if req.credentials
+            headers['Authorization'] = WebMock::Util::Headers.basic_auth_header(req.credentials)
+          end
+
+          request_signature = WebMock::RequestSignature.new(
+            req.action,
+            uri.to_s,
+            body: request_body,
+            headers: headers
+          )
+          request_signature
+        end
+
+        def self.build_patron_response(webmock_response, default_response_charset)
+          raise ::Patron::TimeoutError if webmock_response.should_timeout
+          webmock_response.raise_error_if_any
+
+          header_fields = (webmock_response.headers || []).map { |(k, vs)| Array(vs).map { |v| "#{k}: #{v}" } }.flatten
+          status_line   = "HTTP/1.1 #{webmock_response.status[0]} #{webmock_response.status[1]}"
+          header_data   = ([status_line] + header_fields).join("\r\n")
+
+          ::Patron::Response.new(
+            "".dup,
+            webmock_response.status[0],
+            0,
+            header_data,
+            webmock_response.body.dup,
+            default_response_charset
+          )
+        end
+
+        def self.build_webmock_response(patron_response)
+          webmock_response = WebMock::Response.new
+          reason = patron_response.status_line.
+            scan(%r(\AHTTP/(\d+(?:\.\d+)?)\s+(\d\d\d)\s*([^\r\n]+)?))[0][2]
+          webmock_response.status = [patron_response.status, reason]
+          webmock_response.body = patron_response.body
+          webmock_response.headers = patron_response.headers
+          webmock_response
+        end
+      end
+    end
+  end
+end

data/lib/webmock/http_lib_adapters/typhoeus_hydra_adapter.rb

@@ -0,0 +1,174 @@
+begin
+  require 'typhoeus'
+rescue LoadError
+  # typhoeus not found
+end
+
+if defined?(Typhoeus)
+  WebMock::VersionChecker.new('Typhoeus', Typhoeus::VERSION, '0.3.2').check_version!
+
+  module WebMock
+    module HttpLibAdapters
+      class TyphoeusAdapter < HttpLibAdapter
+        adapter_for :typhoeus
+
+        def self.enable!
+          @disabled = false
+          add_before_callback
+          add_after_request_callback
+          ::Typhoeus::Config.block_connection = true
+        end
+
+        def self.disable!
+          @disabled = true
+          remove_after_request_callback
+          remove_before_callback
+          ::Typhoeus::Config.block_connection = false
+        end
+
+        def self.disabled?
+          !!@disabled
+        end
+
+        def self.add_before_callback
+          unless Typhoeus.before.include?(BEFORE_CALLBACK)
+            Typhoeus.before << BEFORE_CALLBACK
+          end
+        end
+
+        def self.remove_before_callback
+          Typhoeus.before.delete_if {|v| v == BEFORE_CALLBACK }
+        end
+
+        def self.add_after_request_callback
+          unless Typhoeus.on_complete.include?(AFTER_REQUEST_CALLBACK)
+            Typhoeus.on_complete << AFTER_REQUEST_CALLBACK
+          end
+        end
+
+        def self.remove_after_request_callback
+          Typhoeus.on_complete.delete_if {|v| v == AFTER_REQUEST_CALLBACK }
+        end
+
+        def self.build_request_signature(req)
+          uri = WebMock::Util::URI.heuristic_parse(req.url)
+          uri.path = uri.normalized_path.gsub("[^:]//","/")
+
+          headers = req.options[:headers]
+
+          if req.options[:userpwd]
+            headers['Authorization'] = WebMock::Util::Headers.basic_auth_header(req.options[:userpwd])
+          end
+
+          body = req.options[:body]
+
+          if body.is_a?(Hash)
+            body = WebMock::Util::QueryMapper.values_to_query(body)
+          end
+
+          request_signature = WebMock::RequestSignature.new(
+            req.options[:method] || :get,
+            uri.to_s,
+            body: body,
+            headers: headers
+          )
+
+          req.instance_variable_set(:@__webmock_request_signature, request_signature)
+
+          request_signature
+        end
+
+
+        def self.build_webmock_response(typhoeus_response)
+          webmock_response = WebMock::Response.new
+          webmock_response.status = [typhoeus_response.code, typhoeus_response.status_message]
+          webmock_response.body = typhoeus_response.body
+          webmock_response.headers = typhoeus_response.headers
+          webmock_response
+        end
+
+        def self.generate_typhoeus_response(request_signature, webmock_response)
+          response = if webmock_response.should_timeout
+            ::Typhoeus::Response.new(
+              code: 0,
+              status_message: "",
+              body: "",
+              headers: {},
+              return_code: :operation_timedout
+            )
+          else
+            ::Typhoeus::Response.new(
+              code: webmock_response.status[0],
+              status_message: webmock_response.status[1],
+              body: webmock_response.body,
+              headers: webmock_response.headers,
+              effective_url: request_signature.uri
+            )
+          end
+          response.mock = :webmock
+          response
+        end
+
+        def self.request_hash(request_signature)
+          hash = {}
+
+          hash[:body]    = request_signature.body
+          hash[:headers] = request_signature.headers
+
+          hash
+        end
+
+        AFTER_REQUEST_CALLBACK = Proc.new do |response|
+          request = response.request
+          request_signature = request.instance_variable_get(:@__webmock_request_signature)
+          webmock_response =
+            ::WebMock::HttpLibAdapters::TyphoeusAdapter.
+              build_webmock_response(response)
+          if response.mock
+            WebMock::CallbackRegistry.invoke_callbacks(
+              {lib: :typhoeus},
+              request_signature,
+              webmock_response
+            )
+          else
+            WebMock::CallbackRegistry.invoke_callbacks(
+              {lib: :typhoeus, real_request: true},
+              request_signature,
+              webmock_response
+            )
+          end
+        end
+
+        BEFORE_CALLBACK = Proc.new do |request|
+          Typhoeus::Expectation.all.delete_if {|e| e.from == :webmock }
+          res = true
+
+          unless WebMock::HttpLibAdapters::TyphoeusAdapter.disabled?
+            request_signature = ::WebMock::HttpLibAdapters::TyphoeusAdapter.build_request_signature(request)
+            request.block_connection = false;
+
+            ::WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+            if webmock_response = ::WebMock::StubRegistry.instance.response_for_request(request_signature)
+              # ::WebMock::HttpLibAdapters::TyphoeusAdapter.stub_typhoeus(request_signature, webmock_response, self)
+              response = ::WebMock::HttpLibAdapters::TyphoeusAdapter.generate_typhoeus_response(request_signature, webmock_response)
+              if request.respond_to?(:on_headers)
+                request.execute_headers_callbacks(response)
+              end
+              if request.respond_to?(:streaming?) && request.streaming?
+                response.options[:response_body] = ""
+                request.on_body.each { |callback| callback.call(webmock_response.body, response) }
+              end
+              request.finish(response)
+              webmock_response.raise_error_if_any
+              res = false
+            elsif !WebMock.net_connect_allowed?(request_signature.uri)
+              raise WebMock::NetConnectNotAllowedError.new(request_signature)
+            end
+          end
+          res
+        end
+      end
+    end
+  end
+end

data/lib/webmock/matchers/any_arg_matcher.rb

@@ -0,0 +1,13 @@
+module WebMock
+  module Matchers
+    # this is a based on RSpec::Mocks::ArgumentMatchers::AnyArgMatcher
+    class AnyArgMatcher
+      def initialize(ignore)
+      end
+
+      def ==(other)
+        true
+      end
+    end
+  end
+end

data/lib/webmock/matchers/hash_argument_matcher.rb

@@ -0,0 +1,21 @@
+module WebMock
+  module Matchers
+    # Base class for Hash matchers
+    # https://github.com/rspec/rspec-mocks/blob/master/lib/rspec/mocks/argument_matchers.rb
+    class HashArgumentMatcher
+      def initialize(expected)
+        @expected = Hash[WebMock::Util::HashKeysStringifier.stringify_keys!(expected, deep: true).sort]
+      end
+
+      def ==(_actual, &block)
+        @expected.all?(&block)
+      rescue NoMethodError
+        false
+      end
+
+      def self.from_rspec_matcher(matcher)
+        new(matcher.instance_variable_get(:@expected))
+      end
+    end
+  end
+end

data/lib/webmock/matchers/hash_excluding_matcher.rb

@@ -0,0 +1,15 @@
+module WebMock
+  module Matchers
+    # this is a based on RSpec::Mocks::ArgumentMatchers::HashExcludingMatcher
+    # https://github.com/rspec/rspec-mocks/blob/master/lib/rspec/mocks/argument_matchers.rb
+    class HashExcludingMatcher < HashArgumentMatcher
+      def ==(actual)
+        super { |key, value| !actual.key?(key) || value != actual[key] }
+      end
+
+      def inspect
+        "hash_excluding(#{@expected.inspect})"
+      end
+    end
+  end
+end

data/lib/webmock/matchers/hash_including_matcher.rb

@@ -0,0 +1,17 @@
+module WebMock
+  module Matchers
+    # this is a based on RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher
+    # https://github.com/rspec/rspec-mocks/blob/master/lib/rspec/mocks/argument_matchers.rb
+    class HashIncludingMatcher < HashArgumentMatcher
+      def ==(actual)
+        super { |key, value| actual.key?(key) && value === actual[key] }
+      rescue NoMethodError
+        false
+      end
+
+      def inspect
+        "hash_including(#{@expected.inspect})"
+      end
+    end
+  end
+end

data/lib/webmock/minitest.rb

@@ -0,0 +1,41 @@
+begin
+  require 'minitest/test'
+  test_class = Minitest::Test
+  assertions = "assertions"
+rescue LoadError
+  require "minitest/unit"
+  test_class = MiniTest::Unit::TestCase
+  assertions = "_assertions"
+end
+
+require 'webmock'
+
+WebMock.enable!
+
+test_class.class_eval do
+  include WebMock::API
+
+  alias_method :teardown_without_webmock, :teardown
+  def teardown_with_webmock
+    teardown_without_webmock
+    WebMock.reset!
+  end
+  alias_method :teardown, :teardown_with_webmock
+
+  [:assert_request_requested, :assert_request_not_requested].each do |name|
+    alias_method :"#{name}_without_assertions_count", name
+    define_method :"#{name}_with_assertions_count" do |*args|
+      self.send("#{assertions}=", self.send("#{assertions}") + 1)
+      send :"#{name}_without_assertions_count", *args
+    end
+    alias_method name, :"#{name}_with_assertions_count"
+  end
+end
+
+begin
+  error_class = MiniTest::Assertion
+rescue NameError
+  error_class = Minitest::Assertion
+end
+
+WebMock::AssertionFailure.error_class = error_class