vcr 2.1.1 → 2.2.0

data/lib/vcr/configuration.rb

@@ -1,4 +1,3 @@
-require 'fileutils'
 require 'vcr/util/hooks'
 
 module VCR
@@ -8,23 +7,26 @@ module VCR
     include VariableArgsBlockCaller
     include Logger
 
-    # The directory to read cassettes from and write cassettes to.
+    # Gets the directory to read cassettes from and write cassettes to.
+    #
+    # @return [String] the directory to read cassettes from and write cassettes to
+    def cassette_library_dir
+      VCR.cassette_persisters[:file_system].storage_location
+    end
+
+    # Sets the directory to read cassettes from and writes cassettes to.
     #
-    # @overload cassette_library_dir
-    #   @return [String] the directory to read cassettes from and write cassettes to
-    # @overload cassette_library_dir=(dir)
-    #   @param dir [String] the directory to read cassettes from and write cassettes to
-    #   @return [void]
     # @example
     #   VCR.configure do |c|
     #     c.cassette_library_dir = 'spec/cassettes'
     #   end
-    attr_reader :cassette_library_dir
-
-    # Sets the directory to read cassettes from and write cassettes to.
-    def cassette_library_dir=(cassette_library_dir)
-      FileUtils.mkdir_p(cassette_library_dir) if cassette_library_dir
-      @cassette_library_dir = cassette_library_dir ? absolute_path_for(cassette_library_dir) : nil
+    #
+    # @param dir [String] the directory to read cassettes from and write cassettes to
+    # @return [void]
+    # @note This is only necessary if you use the `:file_system`
+    #   cassette persister (the default).
+    def cassette_library_dir=(dir)
+      VCR.cassette_persisters[:file_system].storage_location = dir
     end
 
     # Default options to apply to every cassette.
@@ -162,7 +164,7 @@ module VCR
     #   end
     #
     # @param placeholder [String] The placeholder string.
-    # @param tag [Symbol] Set this apply this to only to cassettes
+    # @param tag [Symbol] Set this to apply this only to cassettes
     #  with a matching tag; otherwise it will apply to every cassette.
     # @yield block that determines what string to replace
     # @yieldparam interaction [(optional) VCR::HTTPInteraction::HookAware] the HTTP interaction
@@ -199,6 +201,23 @@ module VCR
       VCR.cassette_serializers
     end
 
+    # Gets the registry of cassette persisters. Use it to register a custom persister.
+    #
+    # @example
+    #   VCR.configure do |c|
+    #     c.cassette_persisters[:my_custom_persister] = my_custom_persister
+    #   end
+    #
+    # @return [VCR::Cassette::Persisters] the cassette persister registry object.
+    # @note Custom persisters must implement the following interface:
+    #
+    #   * `persister[storage_key]`           # returns previously persisted content
+    #   * `persister[storage_key] = content` # persists given content
+    def cassette_persisters
+      VCR.cassette_persisters
+    end
+
+    define_hook :before_record
     # Adds a callback that will be called before the recorded HTTP interactions
     # are serialized and written to disk.
     #
@@ -222,11 +241,11 @@ module VCR
     #  serialized and written to disk.
     # @yieldparam cassette [(optional) VCR::Cassette] The current cassette.
     # @see #before_playback
-    define_hook :before_record
     def before_record(tag = nil, &block)
-      super(filter_from(tag), &block)
+      super(tag_filter_from(tag), &block)
     end
 
+    define_hook :before_playback
     # Adds a callback that will be called before a previously recorded
     # HTTP interaction is loaded for playback.
     #
@@ -250,9 +269,8 @@ module VCR
     #  loaded.
     # @yieldparam cassette [(optional) VCR::Cassette] The current cassette.
     # @see #before_record
-    define_hook :before_playback
     def before_playback(tag = nil, &block)
-      super(filter_from(tag), &block)
+      super(tag_filter_from(tag), &block)
     end
 
     # Adds a callback that will be called with each HTTP request before it is made.
@@ -273,6 +291,7 @@ module VCR
     # @see #around_http_request
     define_hook :before_http_request
 
+    define_hook :after_http_request, :prepend
     # Adds a callback that will be called with each HTTP request after it is complete.
     #
     # @example
@@ -291,7 +310,9 @@ module VCR
     # @yieldparam response [VCR::Response] the response from the request
     # @see #before_http_request
     # @see #around_http_request
-    define_hook :after_http_request, :prepend
+    def after_http_request(*filters)
+      super(*filters.map { |f| request_filter_from(f) })
+    end
 
     # Adds a callback that will be executed around each HTTP request.
     #
@@ -398,7 +419,9 @@ module VCR
       @default_cassette_options = {
         :record            => :once,
         :match_requests_on => RequestMatcherRegistry::DEFAULT_MATCHERS,
-        :serialize_with    => :yaml
+        :allow_unused_http_interactions => true,
+        :serialize_with    => :yaml,
+        :persist_with      => :file_system
       }
 
       self.debug_logger = NullDebugLogger
@@ -428,15 +451,16 @@ module VCR
       end
     end
 
-    def absolute_path_for(path)
-      Dir.chdir(path) { Dir.pwd }
-    end
-
-    def filter_from(tag)
+    def tag_filter_from(tag)
       return lambda { true } unless tag
       lambda { |_, cassette| cassette.tags.include?(tag) }
     end
 
+    def request_filter_from(object)
+      return object unless object.is_a?(Symbol)
+      lambda { |arg| arg.send(object) }
+    end
+
     def register_built_in_hooks
       before_playback(:update_content_length_header) do |interaction|
         interaction.response.update_content_length_header

data/lib/vcr/errors.rb

@@ -45,6 +45,12 @@ module VCR
     # @see VCR::Response#decompress
     class UnknownContentEncodingError < Error; end
 
+    # Error raised when you eject a cassette before all previously
+    # recorded HTTP interactions are played back.
+    # @note Only applicable when :allow_episode_skipping is false.
+    # @see VCR::HTTPInteractionList#assert_no_unused_interactions!
+    class UnusedHTTPInteractionError < 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

data/lib/vcr/library_hooks/excon.rb

@@ -23,7 +23,7 @@ module VCR
 
       private
 
-        def on_stubbed_request
+        def on_stubbed_by_vcr_request
           @vcr_response = stubbed_response
           {
             :body     => stubbed_response.body,

data/lib/vcr/library_hooks/fakeweb.rb

@@ -40,6 +40,10 @@ module VCR
 
       private
 
+        def externally_stubbed?
+          ::FakeWeb.registered_uri?(request_method, uri)
+        end
+
         def request_type(*args)
           @request_type || super
         end
@@ -64,11 +68,16 @@ module VCR
           super
         end
 
+        def on_externally_stubbed_request
+          # just perform the request--FakeWeb will handle it
+          perform_request(:started)
+        end
+
         def on_recordable_request
           perform_request(net_http.started?, :record_interaction)
         end
 
-        def on_stubbed_request
+        def on_stubbed_by_vcr_request
           with_exclusive_fakeweb_stub(stubbed_response) do
             # force it to be considered started since it doesn't
             # recurse in this case like the others.
@@ -124,9 +133,13 @@ module VCR
           end
         end
 
+        def request_method
+          request.method.downcase.to_sym
+        end
+
         def vcr_request
           @vcr_request ||= VCR::Request.new \
-            request.method.downcase.to_sym,
+            request_method,
             uri,
             (request_body || request.body),
             request.to_hash
@@ -171,7 +184,7 @@ module 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?
+      VCR.turned_on? ? true : allow_net_connect_without_vcr?(*args)
     end
 
     alias allow_net_connect_without_vcr? allow_net_connect?

data/lib/vcr/library_hooks/faraday.rb

@@ -25,8 +25,21 @@ module VCR
         def insert_vcr_middleware
           return if handlers.any? { |h| h.klass == VCR::Middleware::Faraday }
           adapter_index = handlers.index { |h| h.klass < ::Faraday::Adapter }
+          adapter_index ||= handlers.size
+          warn_about_after_adapter_middleware(adapter_index)
           insert_before(adapter_index, VCR::Middleware::Faraday)
         end
+
+        def warn_about_after_adapter_middleware(adapter_index)
+          after_adapter_middleware_count = (handlers.size - adapter_index - 1)
+          return if after_adapter_middleware_count < 1
+
+          after_adapter_middlewares = handlers.last(after_adapter_middleware_count)
+          warn "WARNING: The Faraday connection stack contains middleware after " +
+               "the HTTP adapter (#{after_adapter_middlewares.map(&:inspect).join(', ')}). " +
+               "This is a non-standard configuration and VCR may not be able to " +
+               "record the HTTP requests made through this Faraday connection."
+        end
       end
     end
   end

data/lib/vcr/library_hooks/typhoeus.rb

@@ -25,6 +25,10 @@ module VCR
 
       private
 
+        def externally_stubbed?
+          ::Typhoeus::Hydra.stubs.detect { |stub| stub.matches?(request) }
+        end
+
         def set_typed_request_for_after_hook(*args)
           super
           request.instance_variable_set(:@__typed_vcr_request, @after_hook_typed_request)
@@ -35,7 +39,7 @@ module VCR
           super
         end
 
-        def on_stubbed_request
+        def on_stubbed_by_vcr_request
           ::Typhoeus::Response.new \
             :http_version   => stubbed_response.http_version,
             :code           => stubbed_response.status.code,

data/lib/vcr/library_hooks/webmock.rb

@@ -8,44 +8,103 @@ module VCR
   class LibraryHooks
     # @private
     module WebMock
-      class RequestHandler < ::VCR::RequestHandler
+      extend self
 
-        attr_reader :request
-        def initialize(request)
-          @request = request
-        end
+      attr_accessor :global_hook_disabled
+      alias global_hook_disabled? global_hook_disabled
 
-      private
+      def with_global_hook_disabled
+        self.global_hook_disabled = true
 
-        def set_typed_request_for_after_hook(*args)
-          super
-          request.instance_variable_set(:@__typed_vcr_request, @after_hook_typed_request)
+        begin
+          yield
+        ensure
+          self.global_hook_disabled = false
         end
+      end
 
-        def vcr_request
-          @vcr_request ||= VCR::Request.new \
-            request.method,
-            request.uri.to_s,
-            request.body,
-            request_headers
+      # @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
-            return nil unless request.headers
+          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...
-            request.headers.dup.tap do |headers|
+            webmock_request.headers.dup.tap do |headers|
               headers.delete("Host")
             end
           end
         else
           # @private
-          def request_headers
-            request.headers
+          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
@@ -53,7 +112,7 @@ module VCR
           super
         end
 
-        def on_stubbed_request
+        def on_stubbed_by_vcr_request
           {
             :body    => stubbed_response.body,
             :status  => [stubbed_response.status.code.to_i, stubbed_response.status.message],
@@ -62,22 +121,16 @@ module VCR
         end
       end
 
-      # @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
+      extend Helpers
 
-      ::WebMock.globally_stub_request { |req| RequestHandler.new(req).handle }
+      ::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 \
-            request.send(:instance_variable_get, :@__typed_vcr_request),
-            vcr_response_from(response)
+            typed_request_for(request), vcr_response_for(response)
 
           VCR.record_http_interaction(http_interaction)
         end
@@ -85,8 +138,10 @@ module VCR
 
       ::WebMock.after_request do |request, response|
         unless VCR.library_hooks.disabled?(:webmock)
-          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))
+          VCR.configuration.invoke_hook \
+            :after_http_request,
+            typed_request_for(request, :remove),
+            vcr_response_for(response)
         end
       end
     end
@@ -99,7 +154,7 @@ module 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?
+      VCR.turned_on? ? true : net_connect_allowed_without_vcr?(*args)
     end
 
     alias net_connect_allowed_without_vcr? net_connect_allowed?