mustwin-vcr 2.9.3

data/lib/vcr/library_hooks/webmock.rb

@@ -0,0 +1,164 @@
+require 'vcr/util/version_checker'
+require 'vcr/request_handler'
+require 'webmock'
+
+VCR::VersionChecker.new('WebMock', WebMock.version, '1.8.0').check_version!
+
+module VCR
+  class LibraryHooks
+    # @private
+    module WebMock
+      extend self
+
+      attr_accessor :global_hook_disabled
+      alias global_hook_disabled? global_hook_disabled
+
+      def with_global_hook_disabled
+        self.global_hook_disabled = true
+
+        begin
+          yield
+        ensure
+          self.global_hook_disabled = false
+        end
+      end
+
+      # @private
+      module Helpers
+        def vcr_request_for(webmock_request)
+          VCR::Request.new \
+            webmock_request.method,
+            webmock_request.uri.to_s,
+            webmock_request.body,
+            request_headers_for(webmock_request)
+        end
+
+        # @private
+        def vcr_response_for(webmock_response)
+          VCR::Response.new \
+            VCR::ResponseStatus.new(*webmock_response.status),
+            webmock_response.headers,
+            webmock_response.body,
+            nil
+        end
+
+        if defined?(::Excon)
+          # @private
+          def request_headers_for(webmock_request)
+            return nil unless webmock_request.headers
+
+            # WebMock hooks deeply into a Excon at a place where it manually adds a "Host"
+            # header, but this isn't a header we actually care to store...
+            webmock_request.headers.dup.tap do |headers|
+              headers.delete("Host")
+            end
+          end
+        else
+          # @private
+          def request_headers_for(webmock_request)
+            webmock_request.headers
+          end
+        end
+
+        def typed_request_for(webmock_request, remove = false)
+          if webmock_request.instance_variables.find { |v| v.to_sym == :@__typed_vcr_request }
+            meth = remove ? :remove_instance_variable : :instance_variable_get
+            return webmock_request.send(meth, :@__typed_vcr_request)
+          end
+
+          warn <<-EOS.gsub(/^\s+\|/, '')
+            |WARNING: There appears to be a bug in WebMock's after_request hook
+            |         and VCR is attempting to work around it. Some VCR features
+            |         may not work properly.
+          EOS
+
+          Request::Typed.new(vcr_request_for(webmock_request), :unknown)
+        end
+      end
+
+      class RequestHandler < ::VCR::RequestHandler
+        include Helpers
+
+        attr_reader :request
+        def initialize(request)
+          @request = request
+        end
+
+      private
+
+        def externally_stubbed?
+          # prevent infinite recursion...
+          VCR::LibraryHooks::WebMock.with_global_hook_disabled do
+            ::WebMock.registered_request?(request)
+          end
+        end
+
+        def set_typed_request_for_after_hook(*args)
+          super
+          request.instance_variable_set(:@__typed_vcr_request, @after_hook_typed_request)
+        end
+
+        def vcr_request
+          @vcr_request ||= vcr_request_for(request)
+        end
+
+        def on_externally_stubbed_request
+          # nil allows WebMock to handle the request
+          nil
+        end
+
+        def on_unhandled_request
+          invoke_after_request_hook(nil)
+          super
+        end
+
+        def on_stubbed_by_vcr_request
+          {
+            :body    => stubbed_response.body.dup, # Excon mutates the body, so we must dup it :-(
+            :status  => [stubbed_response.status.code.to_i, stubbed_response.status.message],
+            :headers => stubbed_response.headers
+          }
+        end
+      end
+
+      extend Helpers
+
+      ::WebMock.globally_stub_request do |req|
+        global_hook_disabled? ? nil : RequestHandler.new(req).handle
+      end
+
+      ::WebMock.after_request(:real_requests_only => true) do |request, response|
+        unless VCR.library_hooks.disabled?(:webmock)
+          http_interaction = VCR::HTTPInteraction.new \
+            typed_request_for(request), vcr_response_for(response)
+
+          VCR.record_http_interaction(http_interaction)
+        end
+      end
+
+      ::WebMock.after_request do |request, response|
+        unless VCR.library_hooks.disabled?(:webmock)
+          VCR.configuration.invoke_hook \
+            :after_http_request,
+            typed_request_for(request, :remove),
+            vcr_response_for(response)
+        end
+      end
+    end
+  end
+end
+
+# @private
+module WebMock
+  class << self
+    # ensure HTTP requests are always allowed; VCR takes care of disallowing
+    # them at the appropriate times in its hook
+    def net_connect_allowed_with_vcr?(*args)
+      VCR.turned_on? ? true : net_connect_allowed_without_vcr?(*args)
+    end
+
+    alias net_connect_allowed_without_vcr? net_connect_allowed?
+    alias net_connect_allowed? net_connect_allowed_with_vcr?
+  end unless respond_to?(:net_connect_allowed_with_vcr?)
+end
+

data/lib/vcr/middleware/excon.rb

@@ -0,0 +1,221 @@
+require 'excon'
+require 'vcr/request_handler'
+require 'vcr/util/version_checker'
+
+VCR::VersionChecker.new('Excon', Excon::VERSION, '0.25.2').check_version!
+
+module VCR
+  # Contains middlewares for use with different libraries.
+  module Middleware
+    # Contains Excon middlewares.
+    module Excon
+      # One part of the Excon middleware that uses VCR to record
+      # and replay HTTP requests made through Excon.
+      #
+      # @private
+      class Request < ::Excon::Middleware::Base
+        # @private
+        def request_call(params)
+          params[:vcr_request_handler] = request_handler = RequestHandler.new
+          request_handler.before_request(params)
+
+          super
+        end
+      end
+
+      # One part of the Excon middleware that uses VCR to record
+      # and replay HTTP requests made through Excon.
+      #
+      # @private
+      class Response < ::Excon::Middleware::Base
+        # @private
+        def response_call(params)
+          complete_request(params)
+          super
+        end
+
+        def error_call(params)
+          complete_request(params)
+          super
+        end
+
+      private
+
+        def complete_request(params)
+          if handler = params.delete(:vcr_request_handler)
+            handler.after_request(params[:response])
+          end
+        end
+      end
+
+      # Handles a single Excon request.
+      #
+      # @private
+      class RequestHandler < ::VCR::RequestHandler
+        def initialize
+          @request_params       = nil
+          @response_body_reader = nil
+          @should_record        = false
+        end
+
+        # Performs before_request processing based on the provided
+        # request_params.
+        #
+        # @private
+        def before_request(request_params)
+          @request_params       = request_params
+          @response_body_reader = create_response_body_reader
+          handle
+        end
+
+        # Performs after_request processing based on the provided response.
+        #
+        # @private
+        def after_request(response)
+          vcr_response = vcr_response_for(response)
+
+          if should_record?
+            VCR.record_http_interaction(VCR::HTTPInteraction.new(vcr_request, vcr_response))
+          end
+
+          invoke_after_request_hook(vcr_response)
+        end
+
+        def ensure_response_body_can_be_read_for_error_case
+          # Excon does not invoke the `:response_block` when an error
+          # has occurred, so we need to be sure to use the non-streaming
+          # body reader.
+          @response_body_reader = NonStreamingResponseBodyReader
+        end
+
+        attr_reader :request_params, :response_body_reader
+
+      private
+
+        def externally_stubbed?
+          !!::Excon.stub_for(request_params)
+        end
+
+        def should_record?
+          @should_record
+        end
+
+        def on_stubbed_by_vcr_request
+          request_params[:response] = {
+            :body     => stubbed_response.body.dup, # Excon mutates the body, so we must dup it :-(
+            :headers  => normalized_headers(stubbed_response.headers || {}),
+            :status   => stubbed_response.status.code
+          }
+        end
+
+        def on_recordable_request
+          @should_record = true
+        end
+
+        def create_response_body_reader
+          block = request_params[:response_block]
+          return NonStreamingResponseBodyReader unless block
+
+          StreamingResponseBodyReader.new(block).tap do |response_block_wrapper|
+            request_params[:response_block] = response_block_wrapper
+          end
+        end
+
+        def vcr_request
+          @vcr_request ||= begin
+            headers = request_params[:headers].dup
+            headers.delete("Host")
+
+            VCR::Request.new \
+              request_params[:method],
+              uri,
+              request_params[:body],
+              headers
+          end
+        end
+
+        def vcr_response_for(response)
+          return nil if response.nil?
+
+          VCR::Response.new(
+            VCR::ResponseStatus.new(response.fetch(:status), nil),
+            response.fetch(:headers),
+            response_body_reader.read_body_from(response),
+            nil
+          )
+        end
+
+        def normalized_headers(headers)
+          normalized = {}
+          headers.each do |k, v|
+            v = v.join(', ') if v.respond_to?(:join)
+            normalized[k] = v
+          end
+          normalized
+        end
+
+        if defined?(::Excon::Utils) && ::Excon::Utils.respond_to?(:request_uri)
+          def uri
+            @uri ||= "#{::Excon::Utils.request_uri(request_params)}"
+          end
+        else
+          require 'vcr/middleware/excon/legacy_methods'
+          include LegacyMethods
+
+          def uri
+            @uri ||= "#{request_params[:scheme]}://#{request_params[:host]}:#{request_params[:port]}#{request_params[:path]}#{query}"
+          end
+        end
+      end
+
+      # Wraps an Excon streaming `:response_block`, so that we can
+      # accumulate the response as it streams back from the real HTTP
+      # server in order to record it.
+      #
+      # @private
+      class StreamingResponseBodyReader
+        def initialize(response_block)
+          @response_block = response_block
+          @chunks = []
+        end
+
+        # @private
+        def call(chunk, remaining_bytes, total_bytes)
+          @chunks << chunk
+          @response_block.call(chunk, remaining_bytes, total_bytes)
+        end
+
+        # Provides a duck-typed interface that matches that of
+        # `NonStreamingResponseBodyReader`. The request handler
+        # will use this to get the response body.
+        #
+        # @private
+        def read_body_from(response_params)
+          if @chunks.none?
+            # Not sure why, but sometimes the body comes through the params
+            # instead of via the streaming block even when the block was
+            # configured.
+            response_params[:body]
+          else
+            @chunks.join('')
+          end
+        end
+      end
+
+      # Reads the body when no streaming is done.
+      #
+      # @private
+      class NonStreamingResponseBodyReader
+        # Provides a duck-typed interface that matches that of
+        # `StreamingResponseBodyReader`. The request handler
+        # will use this to get the response body.
+        #
+        # @private
+        def self.read_body_from(response_params)
+          response_params.fetch(:body)
+        end
+      end
+    end
+  end
+end
+

data/lib/vcr/middleware/excon/legacy_methods.rb

@@ -0,0 +1,33 @@
+module VCR
+  module Middleware
+    module Excon
+      # Contains legacy methods only needed when integrating with older versions
+      # of Excon.
+      # @api private
+      module LegacyMethods
+        # based on:
+        # https://github.com/geemus/excon/blob/v0.7.8/lib/excon/connection.rb#L117-132
+        def query
+          @query ||= case request_params[:query]
+            when String
+              "?#{request_params[:query]}"
+            when Hash
+              qry = '?'
+              for key, values in request_params[:query]
+                if values.nil?
+                  qry << key.to_s << '&'
+                else
+                  for value in [*values]
+                    qry << key.to_s << '=' << CGI.escape(value.to_s) << '&'
+                  end
+                end
+              end
+              qry.chop! # remove trailing '&'
+            else
+              ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vcr/middleware/faraday.rb

@@ -0,0 +1,118 @@
+require 'faraday'
+require 'vcr/util/version_checker'
+require 'vcr/request_handler'
+
+VCR::VersionChecker.new('Faraday', Faraday::VERSION, '0.7.0').check_version!
+
+module VCR
+  # Contains middlewares for use with different libraries.
+  module Middleware
+    # Faraday middleware that VCR uses to record and replay HTTP requests made through
+    # Faraday.
+    #
+    # @note You can either insert this middleware into the Faraday middleware stack
+    #  yourself or configure {VCR::Configuration#hook_into} to hook into `:faraday`.
+    class Faraday
+      include VCR::Deprecations::Middleware::Faraday
+
+      # Constructs a new instance of the Faraday middleware.
+      #
+      # @param [#call] app the faraday app
+      def initialize(app)
+        super
+        @app = app
+      end
+
+      # Handles the HTTP request being made through Faraday
+      #
+      # @param [Hash] env the Faraday request env hash
+      def call(env)
+        return @app.call(env) if VCR.library_hooks.disabled?(:faraday)
+        RequestHandler.new(@app, env).handle
+      end
+
+      # @private
+      class RequestHandler < ::VCR::RequestHandler
+        attr_reader :app, :env
+        def initialize(app, env)
+          @app, @env = app, env
+          @has_on_complete_hook = false
+        end
+
+        def handle
+          # Faraday must be exlusive here in case another library hook is being used.
+          # We don't want double recording/double playback.
+          VCR.library_hooks.exclusive_hook = :faraday
+          super
+        ensure
+          response = defined?(@vcr_response) ? @vcr_response : nil
+          invoke_after_request_hook(response) unless delay_finishing?
+        end
+
+      private
+
+        def delay_finishing?
+          !!env[:parallel_manager] && @has_on_complete_hook
+        end
+
+        def vcr_request
+          @vcr_request ||= VCR::Request.new \
+            env[:method],
+            env[:url].to_s,
+            raw_body_from(env[:body]),
+            env[:request_headers]
+        end
+
+        def raw_body_from(body)
+          return body unless body.respond_to?(:read)
+
+          body.read.tap do |b|
+            body.rewind if body.respond_to?(:rewind)
+          end
+        end
+
+        def response_for(response)
+          VCR::Response.new(
+            VCR::ResponseStatus.new(response.status, nil),
+            response.headers,
+            raw_body_from(response.body),
+            nil
+          )
+        end
+
+        def on_ignored_request
+          response = app.call(env)
+          @vcr_response = response_for(response)
+          response
+        end
+
+        def on_stubbed_by_vcr_request
+          headers = env[:response_headers] ||= ::Faraday::Utils::Headers.new
+          headers.update stubbed_response.headers if stubbed_response.headers
+          env.update :status => stubbed_response.status.code, :body => stubbed_response.body
+
+          @vcr_response = stubbed_response
+
+          faraday_response = ::Faraday::Response.new
+          faraday_response.finish(env)
+          env[:response] = faraday_response
+        end
+
+        def on_recordable_request
+          @has_on_complete_hook = true
+          response = app.call(env)
+          response.on_complete do
+            @vcr_response = response_for(response)
+            VCR.record_http_interaction(VCR::HTTPInteraction.new(vcr_request, @vcr_response))
+            invoke_after_request_hook(@vcr_response) if delay_finishing?
+          end
+        end
+
+        def invoke_after_request_hook(response)
+          super
+          VCR.library_hooks.exclusive_hook = nil
+        end
+      end
+    end
+  end
+end