vcr 2.0.0.rc1 → 2.0.0.rc2

data/lib/vcr/deprecations.rb

@@ -1,15 +1,19 @@
 module VCR
+  # @deprecated Use #configure instead.
+  # @see #configure
   def config
     warn "WARNING: `VCR.config` is deprecated.  Use VCR.configure instead."
     configure { |c| yield c }
   end
 
+  # @private
   def self.const_missing(const)
     return super unless const == :Config
     warn "WARNING: `VCR::Config` is deprecated.  Use VCR.configuration instead."
     configuration
   end
 
+  # @private
   def Cassette.const_missing(const)
     return super unless const == :MissingERBVariableError
     warn "WARNING: `VCR::Cassette::MissingERBVariableError` is deprecated.  Use `VCR::Errors::MissingERBVariableError` instead."
@@ -17,14 +21,18 @@ module VCR
   end
 
   class Configuration
+    # @deprecated Use #hook_into instead.
+    # @see #hook_into
     def stub_with(*adapters)
       warn "WARNING: `VCR.config { |c| c.stub_with ... }` is deprecated. Use `VCR.configure { |c| c.hook_into ... }` instead."
       hook_into(*adapters)
     end
   end
 
+  # @private
   module Deprecations
     module Middleware
+      # @private
       module Faraday
         def initialize(*args)
           if block_given?

data/lib/vcr/errors.rb

@@ -1,18 +1,57 @@
 module VCR
+  # Namespace for VCR errors.
   module Errors
+    # Base class for all VCR errors.
     class Error                     < StandardError; end
+
+    # Error raised when VCR is turned off while a cassette is in use.
+    # @see VCR#turn_off!
+    # @see VCR#turned_off
     class CassetteInUseError        < Error; end
+
+    # Error raised when a VCR cassette is inserted while VCR is turned off.
+    # @see VCR#insert_cassette
+    # @see VCR#use_cassette
     class TurnedOffError            < Error; end
+
+    # Error raised when an cassette ERB template is rendered and a
+    # variable is missing.
+    # @see VCR#insert_cassette
+    # @see VCR#use_cassette
     class MissingERBVariableError   < Error; end
+
+    # Error raised when the version of one of the libraries that VCR hooks into
+    # is too low for VCR to support.
+    # @see VCR::Configuration#hook_into
     class LibraryVersionTooLowError < Error; end
+
+    # Error raised when a request matcher is requested that is not registered.
     class UnregisteredMatcherError  < Error; end
+
+    # Error raised when a VCR 1.x cassette is used with VCR 2.
     class InvalidCassetteFormatError < Error; end
+
+    # Error raised when an +around_http_request+ hook is used improperly.
+    # @see VCR::Configuration#around_http_request
     class AroundHTTPRequestHookError < Error; end
+
+    # Error raised when you attempt to use a VCR feature that is not
+    # supported on your ruby interpreter.
+    # @see VCR::Configuration#around_http_request
     class NotSupportedError          < Error; end
 
+    # Error raised when an HTTP request is made that VCR is unable to handle.
+    # @note VCR will raise this to force you to do something about the
+    #  HTTP request. The idea is that you want to handle _every_ HTTP
+    #  request in your test suite. The error message will give you
+    #  suggestions for how to deal with the request.
     class UnhandledHTTPRequestError < Error
+      # The HTTP request.
       attr_reader :request
 
+      # Constructs the error.
+      #
+      # @param [VCR::Request] request the unhandled request.
       def initialize(request)
         @request = request
         super construct_message
@@ -77,6 +116,7 @@ module VCR
         "[#{index + 1}] #{url % relish_version_slug}"
       end
 
+      # List of suggestions for how to configure VCR to handle the request.
       ALL_SUGGESTIONS = {
         :use_new_episodes => [
           ["You can use the :new_episodes record mode to allow VCR to",

data/lib/vcr/extensions/net_http_response.rb

@@ -1,16 +1,17 @@
-# 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 VCR
+  # @private
   module Net
+    # 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.
+    # @private
     module HTTPResponse
       def self.extended(response)
         response.instance_variable_set(:@__read_body_previously_called, false)

data/lib/vcr/library_hooks.rb

@@ -1,4 +1,5 @@
 module VCR
+  # @private
   class LibraryHooks
     attr_accessor :exclusive_hook
 

data/lib/vcr/library_hooks/excon.rb

@@ -2,10 +2,11 @@ require 'vcr/util/version_checker'
 require 'vcr/request_handler'
 require 'excon'
 
-VCR::VersionChecker.new('Excon', Excon::VERSION, '0.6.5', '0.7').check_version!
+VCR::VersionChecker.new('Excon', Excon::VERSION, '0.9.6', '0.9').check_version!
 
 module VCR
   class LibraryHooks
+    # @private
     module Excon
       class RequestHandler < ::VCR::RequestHandler
         attr_reader :params
@@ -45,9 +46,21 @@ module VCR
           end
         end
 
+        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.
+          params.merge(:mock => false, :retry_limit => 0).tap do |p|
+            [:expects, :idempotent, :instrumentor_name, :instrumentor].each do |key|
+              p.delete(key)
+            end
+          end
+        end
+
         def perform_real_request
           begin
-            response = ::Excon.new(uri).request(params.merge(:mock => false))
+            response = ::Excon.new(uri).request(real_request_params)
           rescue ::Excon::Errors::Error => excon_error
             response = response_from_excon_error(excon_error)
           end
@@ -138,5 +151,13 @@ module VCR
   end
 end
 
-Excon.mock = true
+Excon.defaults[:mock] = true
+
+VCR.configuration.after_library_hooks_loaded do
+  # ensure WebMock's Excon adapter does not conflict with us here
+  # (i.e. to double record requests or whatever).
+  if defined?(WebMock::HttpLibAdapters::ExconAdapter)
+    WebMock::HttpLibAdapters::ExconAdapter.disable!
+  end
+end
 

data/lib/vcr/library_hooks/fakeweb.rb

@@ -9,13 +9,21 @@ VCR::VersionChecker.new('FakeWeb', FakeWeb::VERSION, '1.3.0', '1.3').check_versi
 
 module VCR
   class LibraryHooks
+    # @private
     module FakeWeb
+      # @private
       class RequestHandler < ::VCR::RequestHandler
         attr_reader :net_http, :request, :request_body, :response_block
         def initialize(net_http, request, request_body = nil, &response_block)
           @net_http, @request, @request_body, @response_block =
            net_http,  request,  request_body,  response_block
           @vcr_response, @recursing = nil, false
+
+          if ([:@__vcr_request_type, "@__vcr_request_type"] & request.instance_variables).any?
+            @request_type = request.instance_variable_get(:@__vcr_request_type)
+          else
+            @request_type = nil
+          end
         end
 
         def handle
@@ -32,6 +40,15 @@ module VCR
 
       private
 
+        def request_type(*args)
+          @request_type || super
+        end
+
+        def set_typed_request_for_after_hook(request_type)
+          @request.instance_variable_set(:@__vcr_request_type, request_type)
+          super
+        end
+
         def invoke_before_request_hook
           unless self.class.already_seen_requests.include?(request.object_id)
             super
@@ -63,12 +80,6 @@ module VCR
           perform_request(net_http.started?)
         end
 
-        # overriden to prevent it from invoking the after_http_request hook,
-        # since we invoke the hook in an ensure block above.
-        def on_connection_not_allowed
-          raise VCR::Errors::UnhandledHTTPRequestError.new(vcr_request)
-        end
-
         def perform_request(started, record_interaction = false)
           # Net::HTTP calls #request recursively in certain circumstances.
           # We only want to record the request when the request is started, as
@@ -117,7 +128,7 @@ module VCR
           @vcr_request ||= VCR::Request.new \
             request.method.downcase.to_sym,
             uri,
-            request_body,
+            (request_body || request.body),
             request.to_hash
         end
 
@@ -133,7 +144,9 @@ module VCR
   end
 end
 
+# @private
 module Net
+  # @private
   class HTTP
     unless method_defined?(:request_with_vcr)
       def request_with_vcr(*args, &block)
@@ -152,16 +165,19 @@ module Net
   end
 end
 
-class << FakeWeb
-  # ensure HTTP requests are always allowed; VCR takes care of disallowing
-  # them at the appropriate times in its hook
-  def allow_net_connect_with_vcr?(*args)
-    VCR.turned_on? ? true : allow_net_connect_without_vcr?
-  end
+# @private
+module FakeWeb
+  class << self
+    # ensure HTTP requests are always allowed; VCR takes care of disallowing
+    # them at the appropriate times in its hook
+    def allow_net_connect_with_vcr?(*args)
+      VCR.turned_on? ? true : allow_net_connect_without_vcr?
+    end
 
-  alias allow_net_connect_without_vcr? allow_net_connect?
-  alias allow_net_connect? allow_net_connect_with_vcr?
-end unless FakeWeb.respond_to?(:allow_net_connect_with_vcr?)
+    alias allow_net_connect_without_vcr? allow_net_connect?
+    alias allow_net_connect? allow_net_connect_with_vcr?
+  end unless respond_to?(:allow_net_connect_with_vcr?)
+end
 
 VCR.configuration.after_library_hooks_loaded do
   if defined?(WebMock)

data/lib/vcr/library_hooks/faraday.rb

@@ -2,7 +2,9 @@ require 'faraday'
 
 module VCR
   class LibraryHooks
+    # @private
     module Faraday
+      # @private
       module BuilderClassExtension
         def new(*args)
           super.extend BuilderInstanceExtension
@@ -11,6 +13,7 @@ module VCR
         ::Faraday::Builder.extend self
       end
 
+      # @private
       module BuilderInstanceExtension
         def lock!(*args)
           insert_vcr_middleware

data/lib/vcr/library_hooks/typhoeus.rb

@@ -6,42 +6,33 @@ VCR::VersionChecker.new('Typhoeus', Typhoeus::VERSION, '0.3.2', '0.3').check_ver
 
 module VCR
   class LibraryHooks
+    # @private
     module Typhoeus
-      module Helpers
-        def vcr_request_from(request)
-          VCR::Request.new \
-            request.method,
-            request.url,
-            request.body,
-            request.headers
-        end
-
-        def vcr_response_from(response)
-          VCR::Response.new \
-            VCR::ResponseStatus.new(response.code, response.status_message),
-            response.headers_hash,
-            response.body,
-            response.http_version
-        end
-      end
-
+      # @private
       class RequestHandler < ::VCR::RequestHandler
-        include Helpers
-
         attr_reader :request
         def initialize(request)
           @request = request
         end
 
+        def vcr_request
+          @vcr_request ||= VCR::Request.new \
+            request.method,
+            request.url,
+            request.body,
+            request.headers
+        end
+
       private
 
-        def on_connection_not_allowed
-          invoke_after_request_hook(nil)
+        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_from(request)
+        def on_unhandled_request
+          invoke_after_request_hook(nil)
+          super
         end
 
         def on_stubbed_request
@@ -62,17 +53,26 @@ module VCR
         end
       end
 
-      extend Helpers
+      # @private
+      def self.vcr_response_from(response)
+        VCR::Response.new \
+          VCR::ResponseStatus.new(response.code, response.status_message),
+          response.headers_hash,
+          response.body,
+          response.http_version
+      end
+
       ::Typhoeus::Hydra.after_request_before_on_complete do |request|
         unless VCR.library_hooks.disabled?(:typhoeus)
-          vcr_request, vcr_response = vcr_request_from(request), vcr_response_from(request.response)
+          vcr_response = vcr_response_from(request.response)
+          typed_vcr_request = request.send(:remove_instance_variable, :@__typed_vcr_request)
 
           unless request.response.mock?
-            http_interaction = VCR::HTTPInteraction.new(vcr_request, vcr_response)
+            http_interaction = VCR::HTTPInteraction.new(typed_vcr_request, vcr_response)
             VCR.record_http_interaction(http_interaction)
           end
 
-          VCR.configuration.invoke_hook(:after_http_request, vcr_request, vcr_response)
+          VCR.configuration.invoke_hook(:after_http_request, typed_vcr_request, vcr_response)
         end
       end
 
@@ -83,16 +83,19 @@ module VCR
   end
 end
 
-class << Typhoeus::Hydra
-  # ensure HTTP requests are always allowed; VCR takes care of disallowing
-  # them at the appropriate times in its hook
-  def allow_net_connect_with_vcr?(*args)
-    VCR.turned_on? ? true : allow_net_connect_without_vcr?
-  end
+# @private
+module Typhoeus
+  class << Hydra
+    # ensure HTTP requests are always allowed; VCR takes care of disallowing
+    # them at the appropriate times in its hook
+    def allow_net_connect_with_vcr?(*args)
+      VCR.turned_on? ? true : allow_net_connect_without_vcr?
+    end
 
-  alias allow_net_connect_without_vcr? allow_net_connect?
-  alias allow_net_connect? allow_net_connect_with_vcr?
-end unless Typhoeus::Hydra.respond_to?(:allow_net_connect_with_vcr?)
+    alias allow_net_connect_without_vcr? allow_net_connect?
+    alias allow_net_connect? allow_net_connect_with_vcr?
+  end unless Hydra.respond_to?(:allow_net_connect_with_vcr?)
+end
 
 VCR.configuration.after_library_hooks_loaded do
   # ensure WebMock's Typhoeus adapter does not conflict with us here

data/lib/vcr/library_hooks/webmock.rb

@@ -2,31 +2,13 @@ require 'vcr/util/version_checker'
 require 'vcr/request_handler'
 require 'webmock'
 
-VCR::VersionChecker.new('WebMock', WebMock.version, '1.7.8', '1.7').check_version!
+VCR::VersionChecker.new('WebMock', WebMock.version, '1.8.0', '1.8').check_version!
 
 module VCR
   class LibraryHooks
+    # @private
     module WebMock
-      module Helpers
-        def vcr_request_from(webmock_request)
-          VCR::Request.new \
-            webmock_request.method,
-            webmock_request.uri.to_s,
-            webmock_request.body,
-            webmock_request.headers
-        end
-
-        def vcr_response_from(response)
-          VCR::Response.new \
-            VCR::ResponseStatus.new(response.status.first, response.status.last),
-            response.headers,
-            response.body,
-            nil
-        end
-      end
-
       class RequestHandler < ::VCR::RequestHandler
-        include Helpers
 
         attr_reader :request
         def initialize(request)
@@ -35,11 +17,38 @@ module VCR
 
       private
 
+        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_from(request)
+          @vcr_request ||= VCR::Request.new \
+            request.method,
+            request.uri.to_s,
+            request.body,
+            request_headers
+        end
+
+        if defined?(::Excon)
+          # @private
+          def request_headers
+            return nil unless 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...
+            request.headers.dup.tap do |headers|
+              headers.delete("Host")
+            end
+          end
+        else
+          # @private
+          def request_headers
+            request.headers
+          end
         end
 
-        def on_connection_not_allowed
+        def on_unhandled_request
           invoke_after_request_hook(nil)
           super
         end
@@ -53,14 +62,21 @@ module VCR
         end
       end
 
-      extend Helpers
+      # @private
+      def self.vcr_response_from(response)
+        VCR::Response.new \
+          VCR::ResponseStatus.new(response.status.first, response.status.last),
+          response.headers,
+          response.body,
+          nil
+      end
 
       ::WebMock.globally_stub_request { |req| RequestHandler.new(req).handle }
 
       ::WebMock.after_request(:real_requests_only => true) do |request, response|
         unless VCR.library_hooks.disabled?(:webmock)
           http_interaction = VCR::HTTPInteraction.new \
-            vcr_request_from(request),
+            request.send(:instance_variable_get, :@__typed_vcr_request),
             vcr_response_from(response)
 
           VCR.record_http_interaction(http_interaction)
@@ -69,21 +85,25 @@ module VCR
 
       ::WebMock.after_request do |request, response|
         unless VCR.library_hooks.disabled?(:webmock)
-          VCR.configuration.invoke_hook(:after_http_request, vcr_request_from(request), vcr_response_from(response))
+          typed_vcr_request = request.send(:remove_instance_variable, :@__typed_vcr_request)
+          VCR.configuration.invoke_hook(:after_http_request, typed_vcr_request, vcr_response_from(response))
         end
       end
     end
   end
 end
 
-class << WebMock
-  # 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?
-  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?
+    end
 
-  alias net_connect_allowed_without_vcr? net_connect_allowed?
-  alias net_connect_allowed? net_connect_allowed_with_vcr?
-end unless WebMock.respond_to?(:net_connect_allowed_with_vcr?)
+    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