vcr 2.0.0.beta2 → 2.0.0.rc1

data/lib/vcr/library_hooks/faraday.rb

@@ -1,3 +1,31 @@
-Kernel.warn "WARNING: `VCR.config { |c| c.stub_with :faraday }` is deprecated. " +
-            "Just use `VCR::Middleware::Faraday` in your faraday stack."
+require 'faraday'
+
+module VCR
+  class LibraryHooks
+    module Faraday
+      module BuilderClassExtension
+        def new(*args)
+          super.extend BuilderInstanceExtension
+        end
+
+        ::Faraday::Builder.extend self
+      end
+
+      module BuilderInstanceExtension
+        def lock!(*args)
+          insert_vcr_middleware
+          super
+        end
+
+      private
+
+        def insert_vcr_middleware
+          return if handlers.any? { |h| h.klass == VCR::Middleware::Faraday }
+          adapter_index = handlers.index { |h| h.klass < ::Faraday::Adapter }
+          insert_before(adapter_index, VCR::Middleware::Faraday)
+        end
+      end
+    end
+  end
+end
 

data/lib/vcr/library_hooks/typhoeus.rb

@@ -35,6 +35,11 @@ module VCR
 
       private
 
+        def on_connection_not_allowed
+          invoke_after_request_hook(nil)
+          super
+        end
+
         def vcr_request
           @vcr_request ||= vcr_request_from(request)
         end
@@ -59,9 +64,15 @@ module VCR
 
       extend Helpers
       ::Typhoeus::Hydra.after_request_before_on_complete do |request|
-        unless VCR.library_hooks.disabled?(:typhoeus) || request.response.mock?
-          http_interaction = VCR::HTTPInteraction.new(vcr_request_from(request), vcr_response_from(request.response))
-          VCR.record_http_interaction(http_interaction)
+        unless VCR.library_hooks.disabled?(:typhoeus)
+          vcr_request, vcr_response = vcr_request_from(request), vcr_response_from(request.response)
+
+          unless request.response.mock?
+            http_interaction = VCR::HTTPInteraction.new(vcr_request, vcr_response)
+            VCR.record_http_interaction(http_interaction)
+          end
+
+          VCR.configuration.invoke_hook(:after_http_request, vcr_request, vcr_response)
         end
       end
 
@@ -72,6 +83,17 @@ 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
+
+  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?)
+
 VCR.configuration.after_library_hooks_loaded do
   # ensure WebMock's Typhoeus adapter does not conflict with us here
   # (i.e. to double record requests or whatever).

data/lib/vcr/library_hooks/webmock.rb

@@ -2,20 +2,12 @@ require 'vcr/util/version_checker'
 require 'vcr/request_handler'
 require 'webmock'
 
-VCR::VersionChecker.new('WebMock', WebMock.version, '1.7.0', '1.7').check_version!
+VCR::VersionChecker.new('WebMock', WebMock.version, '1.7.8', '1.7').check_version!
 
 module VCR
   class LibraryHooks
     module WebMock
       module Helpers
-        def response_hash_for(response)
-          {
-            :body    => response.body,
-            :status  => [response.status.code.to_i, response.status.message],
-            :headers => response.headers
-          }
-        end
-
         def vcr_request_from(webmock_request)
           VCR::Request.new \
             webmock_request.method,
@@ -43,30 +35,27 @@ module VCR
 
       private
 
-        def stubbed_response
-          VCR.http_interactions.has_interaction_matching?(vcr_request)
-        end
-
         def vcr_request
           @vcr_request ||= vcr_request_from(request)
         end
 
-        def on_ignored_request;    false; end
-        def on_stubbed_request;    true;  end
-        def on_recordable_request; false; end
+        def on_connection_not_allowed
+          invoke_after_request_hook(nil)
+          super
+        end
+
+        def on_stubbed_request
+          {
+            :body    => stubbed_response.body,
+            :status  => [stubbed_response.status.code.to_i, stubbed_response.status.message],
+            :headers => stubbed_response.headers
+          }
+        end
       end
 
       extend Helpers
 
-      GLOBAL_VCR_HOOK = ::WebMock::RequestStub.new(:any, /.*/).tap do |stub|
-        stub.with { |request|
-          RequestHandler.new(request).handle
-        }.to_return(lambda { |request|
-          response_hash_for VCR.http_interactions.response_for(vcr_request_from(request))
-        })
-      end
-
-      ::WebMock::StubRegistry.instance.register_request_stub(GLOBAL_VCR_HOOK)
+      ::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)
@@ -77,6 +66,12 @@ module VCR
           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, vcr_request_from(request), vcr_response_from(response))
+        end
+      end
     end
   end
 end
@@ -84,17 +79,11 @@ end
 class << WebMock
   # ensure HTTP requests are always allowed; VCR takes care of disallowing
   # them at the appropriate times in its hook
-  undef net_connect_allowed?
-  def net_connect_allowed?(*args)
-    true
+  def net_connect_allowed_with_vcr?(*args)
+    VCR.turned_on? ? true : net_connect_allowed_without_vcr?
   end
-end
 
-WebMock::StubRegistry.class_eval do
-  # ensure our VCR hook is not removed when WebMock is reset
-  undef reset!
-  def reset!
-    self.request_stubs = [VCR::LibraryHooks::WebMock::GLOBAL_VCR_HOOK]
-  end
-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?)
 

data/lib/vcr/middleware/faraday.rb

@@ -15,21 +15,31 @@ module VCR
       end
 
       def call(env)
-        # Faraday must be exlusive here in case another library hook is being used.
-        # We don't want double recording/double playback.
-        VCR.library_hooks.exclusively_enabled(:faraday) do
-          RequestHandler.new(@app, env).handle
-        end
+        RequestHandler.new(@app, env).handle
       end
 
       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
+          invoke_after_request_hook(response_for(env)) 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],
@@ -40,6 +50,7 @@ module VCR
 
         def response_for(env)
           response = env[:response]
+          return nil unless response
 
           VCR::Response.new(
             VCR::ResponseStatus.new(response.status, nil),
@@ -64,10 +75,17 @@ module VCR
         end
 
         def on_recordable_request
+          @has_on_complete_hook = true
           app.call(env).on_complete do |env|
             VCR.record_http_interaction(VCR::HTTPInteraction.new(vcr_request, response_for(env)))
+            invoke_after_request_hook(response_for(env)) if delay_finishing?
           end
         end
+
+        def invoke_after_request_hook(response)
+          super
+          VCR.library_hooks.exclusive_hook = nil
+        end
       end
     end
   end

data/lib/vcr/request_handler.rb

@@ -1,6 +1,7 @@
 module VCR
   class RequestHandler
     def handle
+      invoke_before_request_hook
       return on_ignored_request    if should_ignore?
       return on_stubbed_request    if stubbed_response
       return on_recordable_request if VCR.real_http_connections_allowed?
@@ -9,6 +10,16 @@ module VCR
 
   private
 
+    def invoke_before_request_hook
+      return if disabled?
+      VCR.configuration.invoke_hook(:before_http_request, vcr_request)
+    end
+
+    def invoke_after_request_hook(vcr_response)
+      return if disabled?
+      VCR.configuration.invoke_hook(:after_http_request, vcr_request, vcr_response)
+    end
+
     def should_ignore?
       disabled? || VCR.request_ignorer.ignore?(vcr_request)
     end
@@ -37,7 +48,7 @@ module VCR
     end
 
     def on_connection_not_allowed
-      raise VCR::HTTPConnectionNotAllowedError.new(vcr_request)
+      raise VCR::Errors::UnhandledHTTPRequestError.new(vcr_request)
     end
   end
 end

data/lib/vcr/request_ignorer.rb

@@ -1,10 +1,21 @@
 require 'uri'
 require 'set'
+require 'vcr/util/hooks'
 
 module VCR
   class RequestIgnorer
+    include VCR::Hooks
+
+    define_hook :ignore_request
+
     LOCALHOST_ALIASES = %w( localhost 127.0.0.1 0.0.0.0 )
 
+    def initialize
+      ignore_request do |request|
+        ignored_hosts.include?(URI(request.uri).host)
+      end
+    end
+
     def ignore_localhost=(value)
       if value
         ignore_hosts(*LOCALHOST_ALIASES)
@@ -18,7 +29,7 @@ module VCR
     end
 
     def ignore?(request)
-      ignored_hosts.include?(URI(request.uri).host)
+      invoke_hook(:ignore_request, request).any?
     end
 
   private

data/lib/vcr/request_matcher_registry.rb

@@ -80,20 +80,12 @@ module VCR
 
     def register_built_ins
       register(:method)  { |r1, r2| r1.method == r2.method }
-      register(:uri)     { |r1, r2| without_standard_port(r1.uri) == without_standard_port(r2.uri) }
+      register(:uri)     { |r1, r2| r1.uri == r2.uri }
       register(:host)    { |r1, r2| URI(r1.uri).host == URI(r2.uri).host }
       register(:path)    { |r1, r2| URI(r1.uri).path == URI(r2.uri).path }
       register(:body)    { |r1, r2| r1.body == r2.body }
       register(:headers) { |r1, r2| r1.headers == r2.headers }
     end
-
-    def without_standard_port(uri)
-      URI(uri).tap do |u|
-        if [['http', 80], ['https', 443]].include?([u.scheme, u.port])
-          u.port = nil
-        end
-      end
-    end
   end
 end
 

data/lib/vcr/structs.rb

@@ -78,6 +78,12 @@ module VCR
     include Normalizers::Header
     include Normalizers::Body
 
+    def initialize(*args)
+      super
+      self.method = self.method.to_s.downcase.to_sym if self.method
+      self.uri = without_standard_port(self.uri)
+    end
+
     def to_hash
       {
         'method'  => method.to_s,
@@ -101,6 +107,31 @@ module VCR
       return super if args.empty?
       @@object_method.bind(self).call(*args)
     end
+
+    # transforms the request into a fiber aware one
+    def fiber_aware
+      extend FiberAware
+    end
+
+    module FiberAware
+      def proceed
+        Fiber.yield
+      end
+
+      def to_proc
+        lambda { proceed }
+      end
+    end
+
+  private
+
+    def without_standard_port(uri)
+      return uri if uri.nil?
+      u = URI(uri)
+      return uri unless [['http', 80], ['https', 443]].include?([u.scheme, u.port])
+      u.port = nil
+      u.to_s
+    end
   end
 
   class HTTPInteraction < Struct.new(:request, :response, :recorded_at)
@@ -188,8 +219,7 @@ module VCR
     end
 
     def update_content_length_header
-      # TODO: should this be the bytesize?
-      value = body ? body.length.to_s : '0'
+      value = body ? body.bytesize.to_s : '0'
       key = %w[ Content-Length content-length ].find { |k| headers.has_key?(k) }
       headers[key] = [value] if key
     end

data/lib/vcr/test_frameworks/rspec.rb

@@ -32,6 +32,34 @@ module VCR
         group_descriptions.compact.reverse.join('/')
       end
     end
+
+    module Metadata
+      extend self
+
+      def configure!
+        ::RSpec.configure do |config|
+          vcr_cassette_name_for = lambda do |metadata|
+            description = metadata[:description]
+
+            if example_group = metadata[:example_group]
+              [vcr_cassette_name_for[example_group], description].join('/')
+            else
+              description
+            end
+          end
+
+          config.around(:each, :vcr => lambda { |v| !!v }) do |example|
+            options = example.metadata[:vcr]
+            options = {} unless options.is_a?(Hash) # in case it's just :vcr => true
+
+            cassette_name = options.delete(:cassette_name) ||
+                            vcr_cassette_name_for[example.metadata]
+
+            VCR.use_cassette(cassette_name, options, &example)
+          end
+        end
+      end
+    end
   end
 end
 

data/lib/vcr/util/hooks.rb

@@ -1,3 +1,5 @@
+require 'vcr/util/variable_args_block_caller'
+
 module VCR
   module Hooks
     include VariableArgsBlockCaller
@@ -6,8 +8,12 @@ module VCR
       klass.extend(ClassMethods)
     end
 
-    def invoke_hook(hook, tag=nil, *args)
-      hooks_for(hook, tag).each do |callback|
+    def invoke_hook(hook, *args)
+      invoke_tagged_hook(hook, nil, *args)
+    end
+
+    def invoke_tagged_hook(hook, tag, *args)
+      hooks_for(hook, tag).map do |callback|
         call_block(callback, *args)
       end
     end
@@ -34,7 +40,9 @@ module VCR
     end
 
     module ClassMethods
-      def define_hook(hook)
+      def define_hook(hook, prepend = false)
+        placement_method = prepend ? :unshift : :<<
+
         # We use splat args here because 1.8.7 doesn't allow default
         # values for block arguments, so we have to fake it.
         define_method hook do |*args, &block|
@@ -43,7 +51,7 @@ module VCR
           end
 
           tag = args.first
-          hooks[hook][tag] << block
+          hooks[hook][tag].send(placement_method, block)
         end
       end
     end