vcr 2.4.0 → 2.5.0

data/lib/vcr/cassette/migrator.rb

@@ -101,9 +101,16 @@ module VCR
           join('-')
       end
 
+      EMPTY_STRING = if String.method_defined?(:force_encoding)
+        ''.force_encoding("US-ASCII")
+      else
+        ''
+      end
+
       def normalize_body(object)
-        object.body = '' if object.body.nil?
+        object.body = EMPTY_STRING if object.body.nil?
       end
+
     end
   end
 end

data/lib/vcr/configuration.rb

@@ -392,13 +392,16 @@ module VCR
         "VCR::Configuration#around_http_request requires fibers, " +
         "which are not available on your ruby intepreter."
     else
-      fiber, hook_allowed, hook_decaration = nil, false, caller.first
+      fibers = {}
+      hook_allowed, hook_decaration = false, caller.first
       before_http_request(*filters) do |request|
         hook_allowed = true
         fiber = start_new_fiber_for(request, block)
+        fibers[Thread.current] = fiber
       end
 
       after_http_request(lambda { hook_allowed }) do |request, response|
+        fiber = fibers.delete(Thread.current)
         resume_fiber(fiber, response, hook_decaration)
       end
     end
@@ -406,7 +409,10 @@ module VCR
     # Configures RSpec to use a VCR cassette for any example
     # tagged with `:vcr`.
     def configure_rspec_metadata!
-      VCR::RSpec::Metadata.configure!
+      unless @rspec_metadata_configured
+        VCR::RSpec::Metadata.configure!
+        @rspec_metadata_configured = true
+      end
     end
 
     # An object to log debug output to.
@@ -462,6 +468,7 @@ module VCR
 
     def initialize
       @allow_http_connections_when_no_cassette = nil
+      @rspec_metadata_configured = false
       @default_cassette_options = {
         :record            => :once,
         :match_requests_on => RequestMatcherRegistry::DEFAULT_MATCHERS,

data/lib/vcr/library_hooks/excon.rb

@@ -1,188 +1,6 @@
-require 'vcr/util/version_checker'
-require 'vcr/request_handler'
-require 'excon'
+require 'vcr/middleware/excon'
 
-VCR::VersionChecker.new('Excon', Excon::VERSION, '0.9.6', '0.16').check_version!
-
-module VCR
-  class LibraryHooks
-    # @private
-    module Excon
-      class RequestHandler < ::VCR::RequestHandler
-        attr_reader :params
-        def initialize(params)
-          @vcr_response = nil
-          @params = params
-        end
-
-        def handle
-          super
-        ensure
-          invoke_after_request_hook(@vcr_response)
-        end
-
-      private
-
-        def on_stubbed_by_vcr_request
-          @vcr_response = stubbed_response
-          {
-            :body     => stubbed_response.body,
-            :headers  => normalized_headers(stubbed_response.headers || {}),
-            :status   => stubbed_response.status.code
-          }
-        end
-
-        def on_ignored_request
-          perform_real_request
-        end
-
-        def response_from_excon_error(error)
-          if error.respond_to?(:response)
-            error.response
-          elsif error.respond_to?(:socket_error)
-            response_from_excon_error(error.socket_error)
-          else
-            warn "WARNING: VCR could not extract a response from Excon error (#{error.inspect})"
-          end
-        end
-
-        PARAMS_TO_DELETE = [:expects, :idempotent,
-                            :instrumentor_name, :instrumentor,
-                            :response_block, :request_block]
-
-        def real_request_params
-          # Excon supports a variety of options that affect how it handles failure
-          # and retry; we don't want to use any options here--we just want to get
-          # a raw response, and then the main request (with :mock => true) can
-          # handle failure/retry on its own with its set options.
-          scrub_params_from params.merge(:mock => false, :retry_limit => 0)
-        end
-
-        def new_connection
-          # Ensure the connection is constructed with the exact same args
-          # that the orginal connection was constructed with.
-          args, options = params.fetch(:__construction_args)
-          options = scrub_params_from(options) if options.is_a?(Hash)
-          ::Excon::Connection.new(*[args, options].compact)
-        end
-
-        def scrub_params_from(hash)
-          hash = hash.dup
-          PARAMS_TO_DELETE.each { |key| hash.delete(key) }
-          hash
-        end
-
-        def perform_real_request
-          begin
-            response = new_connection.request(real_request_params)
-          rescue ::Excon::Errors::Error => excon_error
-            response = response_from_excon_error(excon_error)
-          end
-
-          @vcr_response = vcr_response_from(response)
-          yield response if block_given?
-          raise excon_error if excon_error
-
-          response.attributes
-        end
-
-        def on_recordable_request
-          perform_real_request do |response|
-            http_interaction = http_interaction_for(response)
-            VCR.record_http_interaction(http_interaction)
-          end
-        end
-
-        def uri
-          @uri ||= "#{params[:scheme]}://#{params[:host]}:#{params[:port]}#{params[:path]}#{query}"
-        end
-
-        # based on:
-        # https://github.com/geemus/excon/blob/v0.7.8/lib/excon/connection.rb#L117-132
-        def query
-          @query ||= case params[:query]
-            when String
-              "?#{params[:query]}"
-            when Hash
-              qry = '?'
-              for key, values in 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
-
-        def http_interaction_for(response)
-          VCR::HTTPInteraction.new \
-            vcr_request,
-            vcr_response_from(response)
-        end
-
-        def vcr_request
-          @vcr_request ||= begin
-            headers = params[:headers].dup
-            headers.delete("Host")
-
-            VCR::Request.new \
-              params[:method],
-              uri,
-              params[:body],
-              headers
-          end
-        end
-
-        def vcr_response_from(response)
-          VCR::Response.new \
-            VCR::ResponseStatus.new(response.status, nil),
-            response.headers,
-            response.body,
-            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
-
-        ::Excon.stub({}) do |params|
-          self.new(params).handle
-        end
-      end
-
-    end
-  end
-end
-
-::Excon.defaults[:mock] = true
-
-# We want to get at the Excon::Connection class but WebMock does
-# some constant-replacing stuff to it, so we need to take that into
-# account.
-excon_connection = if defined?(::WebMock::HttpLibAdapters::ExconConnection)
-  ::WebMock::HttpLibAdapters::ExconConnection.superclass
-else
-  ::Excon::Connection
-end
-
-excon_connection.class_eval do
-  def self.new(*args)
-    super.tap do |instance|
-      instance.connection[:__construction_args] = args
-    end
-  end
-end
+Excon.defaults[:middlewares] << VCR::Middleware::Excon
 
 VCR.configuration.after_library_hooks_loaded do
   # ensure WebMock's Excon adapter does not conflict with us here

data/lib/vcr/library_hooks/typhoeus.rb

@@ -5,7 +5,7 @@ require 'typhoeus'
 if Float(Typhoeus::VERSION[/^\d+\.\d+/]) < 0.5
   require 'vcr/library_hooks/typhoeus_0.4'
 else
-  VCR::VersionChecker.new('Typhoeus', Typhoeus::VERSION, '0.5.0', '0.5').check_version!
+  VCR::VersionChecker.new('Typhoeus', Typhoeus::VERSION, '0.5.0', '0.6').check_version!
 
   module VCR
     class LibraryHooks

data/lib/vcr/library_hooks/typhoeus_0.4.rb

@@ -97,3 +97,7 @@ module Typhoeus
   end unless Hydra.respond_to?(:allow_net_connect_with_vcr?)
 end
 
+VCR.configuration.after_library_hooks_loaded do
+  ::Kernel.warn "WARNING: VCR's Typhoeus 0.4 integration is deprecated and will be removed in VCR 3.0."
+end
+

data/lib/vcr/library_hooks/webmock.rb

@@ -2,7 +2,7 @@ require 'vcr/util/version_checker'
 require 'vcr/request_handler'
 require 'webmock'
 
-VCR::VersionChecker.new('WebMock', WebMock.version, '1.8.0', '1.9').check_version!
+VCR::VersionChecker.new('WebMock', WebMock.version, '1.8.0', '1.11').check_version!
 
 module VCR
   class LibraryHooks

data/lib/vcr/middleware/excon.rb

@@ -0,0 +1,226 @@
+require 'excon'
+require 'vcr/request_handler'
+require 'vcr/util/version_checker'
+
+VCR::VersionChecker.new('Excon', Excon::VERSION, '0.22.0', '0.22').check_version!
+
+module VCR
+  # Contains middlewares for use with different libraries.
+  module Middleware
+    # Excon middleware that uses VCR to record and replay HTTP requests made
+    # through Excon.
+    #
+    # @note You can either add this to the middleware stack of an Excon connection
+    #   yourself, or configure {VCR::Configuration#hook_into} to hook into `:excon`.
+    #   Setting the config option will add this middleware to Excon's default
+    #   middleware stack.
+    class Excon < ::Excon::Middleware::Base
+      # @private
+      def initialize(*args)
+        # Excon appears to create a new instance of this middleware for each
+        # request, which means it should be safe to store per-request state
+        # like this request_handler object on the middleware instance.
+        # I'm not 100% sure about this yet and should verify with @geemus.
+        @request_handler = RequestHandler.new
+        super
+      end
+
+      # @private
+      def request_call(params)
+        @request_handler.before_request(params)
+        super
+      end
+
+      # @private
+      def response_call(params)
+        @request_handler.after_request(params)
+        super
+      end
+
+      # @private
+      def error_call(params)
+        @request_handler.after_request(params)
+        super
+      end
+
+      # Handles a single Excon request.
+      #
+      # @private
+      class RequestHandler < ::VCR::RequestHandler
+        def initialize
+          @request_params       = nil
+          @response_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_params.
+        #
+        # @private
+        def after_request(response_params)
+          # If @response_params is already set, it indicates we've already run the
+          # after_request logic. This can happen when if the response triggers an error,
+          # whch would then trigger the error_call middleware callback, leading to this
+          # being called a second time.
+          return if @response_params
+
+          @response_params = response_params
+
+          if should_record?
+            VCR.record_http_interaction(VCR::HTTPInteraction.new(vcr_request, vcr_response))
+          end
+
+          invoke_after_request_hook(vcr_response)
+        end
+
+        attr_reader :request_params, :response_params, :response_body_reader
+
+      private
+
+        def should_record?
+          @should_record
+        end
+
+        def on_stubbed_by_vcr_request
+          request_params[:response] = {
+            :body     => stubbed_response.body,
+            :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
+          return @vcr_response if defined?(@vcr_response)
+
+          if should_record? || response_params.has_key?(:response)
+            response = response_params.fetch(:response)
+
+            @vcr_response = VCR::Response.new(
+              VCR::ResponseStatus.new(response.fetch(:status), nil),
+              response.fetch(:headers),
+              response_body_reader.read_body_from(response),
+              nil
+            )
+          else
+            @vcr_response = nil
+          end
+        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
+
+        def uri
+          @uri ||= "#{request_params[:scheme]}://#{request_params[:host]}:#{request_params[:port]}#{request_params[:path]}#{query}"
+        end
+
+        # 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
+
+      # 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)
+          @chunks.join('')
+        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
+