vcr 2.0.0.beta2 → 2.0.0.rc1

data/lib/vcr/cassette/migrator.rb

@@ -42,7 +42,7 @@ module VCR
 
         hash = {
           "http_interactions" => http_interactions,
-          "recorded_with"     => "VCR 1.11.3" # assume the last 1.x release
+          "recorded_with"     => "VCR #{VCR.version}"
         }
 
         def hash.each

data/lib/vcr/configuration.rb

@@ -9,6 +9,8 @@ module VCR
     define_hook :before_record
     define_hook :before_playback
     define_hook :after_library_hooks_loaded
+    define_hook :before_http_request
+    define_hook :after_http_request, :prepend
 
     def initialize
       @allow_http_connections_when_no_cassette = nil
@@ -48,6 +50,10 @@ module VCR
       VCR.request_ignorer.ignore_localhost = value
     end
 
+    def ignore_request(&block)
+      VCR.request_ignorer.ignore_request(&block)
+    end
+
     attr_writer :allow_http_connections_when_no_cassette
     def allow_http_connections_when_no_cassette?
       !!@allow_http_connections_when_no_cassette
@@ -62,11 +68,28 @@ module VCR
         interaction.filter!(placeholder, call_block(block, interaction))
       end
     end
+    alias define_cassette_placeholder filter_sensitive_data
 
     def cassette_serializers
       VCR.cassette_serializers
     end
 
+    def around_http_request(&block)
+      require 'fiber'
+    rescue LoadError
+      raise Errors::NotSupportedError.new \
+        "VCR::Configuration#around_http_request requires fibers, " +
+        "which are not available on your ruby intepreter."
+    else
+      fiber, hook_decaration = nil, caller.first
+      before_http_request { |request| fiber = start_new_fiber_for(request, block) }
+      after_http_request  { |request| resume_fiber(fiber, hook_decaration) }
+    end
+
+    def configure_rspec_metadata!
+      VCR::RSpec::Metadata.configure!
+    end
+
   private
 
     def load_library_hook(hook)
@@ -76,6 +99,20 @@ module VCR
       raise e unless e.message.include?(file) # in case FakeWeb/WebMock/etc itself is not available
       raise ArgumentError.new("#{hook.inspect} is not a supported VCR HTTP library hook.")
     end
+
+    def resume_fiber(fiber, hook_declaration)
+      fiber.resume
+    rescue FiberError
+      raise Errors::AroundHTTPRequestHookError.new \
+        "Your around_http_request hook declared at #{hook_declaration}" +
+        " must call #proceed on the yielded request but did not."
+    end
+
+    def start_new_fiber_for(request, block)
+      Fiber.new(&block).tap do |fiber|
+        fiber.resume(request.fiber_aware)
+      end
+    end
   end
 end
 

data/lib/vcr/errors.rb

@@ -7,15 +7,181 @@ module VCR
     class LibraryVersionTooLowError < Error; end
     class UnregisteredMatcherError  < Error; end
     class InvalidCassetteFormatError < Error; end
+    class AroundHTTPRequestHookError < Error; end
+    class NotSupportedError          < Error; end
+
+    class UnhandledHTTPRequestError < Error
+      attr_reader :request
 
-    class HTTPConnectionNotAllowedError < Error
       def initialize(request)
-        super \
-          "Real HTTP connections are disabled. " +
-          "Request: #{request.method.to_s.upcase} #{request.uri}. " +
-          "You can use VCR to automatically record this request and replay it later. " +
-          "For more details, visit the VCR documentation at: http://relishapp.com/myronmarston/vcr/v/#{VCR.version.gsub('.', '-')}"
+        @request = request
+        super construct_message
+      end
+
+    private
+
+      def relish_version_slug
+        @relish_version_slug ||= VCR.version.gsub(/\W/, '-')
+      end
+
+      def construct_message
+        ["", "", "=" * 80,
+         "An HTTP request has been made that VCR does not know how to handle:",
+         "  #{request_description}\n",
+         cassette_description,
+         formatted_suggestions,
+         "=" * 80, "", ""].join("\n")
+      end
+
+      def request_description
+        "#{request.method.to_s.upcase} #{request.uri}"
+      end
+
+      def cassette_description
+        if cassette = VCR.current_cassette
+          ["VCR is currently using the following cassette:",
+           "  - #{cassette.file}",
+           "  - :record => #{cassette.record_mode.inspect}",
+           "  - :match_requests_on => #{cassette.match_requests_on.inspect}\n",
+           "Under the current configuration VCR can not find a suitable HTTP interaction",
+           "to replay and is prevented from recording new requests. There are a few ways",
+           "you can deal with this:\n"].join("\n")
+        else
+          ["There is currently no cassette in use. There are a few ways",
+           "you can configure VCR to handle this request:\n"].join("\n")
+        end
+      end
+
+      def formatted_suggestions
+        formatted_points, formatted_foot_notes = [], []
+
+        suggestions.each_with_index do |suggestion, index|
+          bullet_point, foot_note = suggestion.first, suggestion.last
+          formatted_points << format_bullet_point(bullet_point, index)
+          formatted_foot_notes << format_foot_note(foot_note, index)
+        end
+
+        [
+          formatted_points.join("\n"),
+          formatted_foot_notes.join("\n")
+        ].join("\n\n")
+      end
+
+      def format_bullet_point(lines, index)
+        lines.first.insert(0, "  * ")
+        lines.last << " [#{index + 1}]."
+        lines.join("\n    ")
+      end
+
+      def format_foot_note(url, index)
+        "[#{index + 1}] #{url % relish_version_slug}"
+      end
+
+      ALL_SUGGESTIONS = {
+        :use_new_episodes => [
+          ["You can use the :new_episodes record mode to allow VCR to",
+           "record this new request to the existing cassette"],
+          "https://www.relishapp.com/myronmarston/vcr/v/%s/docs/record-modes/new-episodes"
+        ],
+
+        :delete_cassette_for_once => [
+          ["The current record mode (:once) does not allow new requests to be recorded",
+           "to a previously recorded cassette. You can delete the cassette file and re-run",
+           "your tests to allow the cassette to be recorded with this request"],
+           "https://www.relishapp.com/myronmarston/vcr/v/%s/docs/record-modes/once"
+        ],
+
+        :deal_with_none => [
+          ["The current record mode (:none) does not allow requests to be recorded. You",
+           "can temporarily change the record mode to :once, delete the cassette file ",
+           "and re-run your tests to allow the cassette to be recorded with this request"],
+           "https://www.relishapp.com/myronmarston/vcr/v/%s/docs/record-modes/none"
+        ],
+
+        :use_a_cassette => [
+          ["If you want VCR to record this request and play it back during future test",
+           "runs, you should wrap your test (or this portion of your test) in a",
+           "`VCR.use_cassette` block"],
+          "https://www.relishapp.com/myronmarston/vcr/v/%s/docs/getting-started"
+        ],
+
+        :allow_http_connections_when_no_cassette => [
+          ["If you only want VCR to handle requests made while a cassette is in use,",
+           "configure `allow_http_connections_when_no_cassette = true`. VCR will",
+           "ignore this request since it is made when there is no cassette"],
+          "https://www.relishapp.com/myronmarston/vcr/v/%s/docs/configuration/allow-http-connections-when-no-cassette"
+        ],
+
+        :ignore_request => [
+          ["If you want VCR to ignore this request (and others like it), you can",
+           "set an `ignore_request` callback"],
+          "https://www.relishapp.com/myronmarston/vcr/v/%s/docs/configuration/ignore-request"
+        ],
+
+        :allow_playback_repeats => [
+          ["The cassette contains an HTTP interaction that matches this request,",
+           "but it has already been played back. If you wish to allow a single HTTP",
+           "interaction to be played back multiple times, set the `:allow_playback_repeats`",
+           "cassette option"],
+          "https://www.relishapp.com/myronmarston/vcr/v/%s/docs/request-matching/playback-repeats"
+        ],
+
+        :match_requests_on => [
+          ["The cassette contains %s not been",
+           "played back. If your request is non-deterministic, you may need to",
+           "change your :match_requests_on cassette option to be more lenient",
+           "or use a custom request matcher to allow it to match"],
+           "https://www.relishapp.com/myronmarston/vcr/v/%s/docs/request-matching"
+        ]
+      }
+
+      def suggestion_for(key)
+        bullet_point_lines, url = ALL_SUGGESTIONS[key]
+        bullet_point_lines = bullet_point_lines.map(&:dup)
+        url = url.dup
+        [bullet_point_lines, url]
+      end
+
+      def suggestions
+        return no_cassette_suggestions unless cassette = VCR.current_cassette
+
+        [:use_new_episodes, :ignore_request].tap do |suggestions|
+          suggestions.push(*record_mode_suggestion)
+          suggestions << :allow_playback_repeats if cassette.http_interactions.has_used_interaction_matching?(request)
+          suggestions.map! { |k| suggestion_for(k) }
+          suggestions.push(*match_requests_on_suggestion)
+        end
+      end
+
+      def no_cassette_suggestions
+        [:use_a_cassette, :allow_http_connections_when_no_cassette, :ignore_request].map do |key|
+          suggestion_for(key)
+        end
+      end
+
+      def record_mode_suggestion
+        case VCR.current_cassette.record_mode
+        when :none then [:deal_with_none]
+        when :once then [:delete_cassette_for_once]
+        else []
+        end
       end
+
+      def match_requests_on_suggestion
+        num_remaining_interactions = VCR.current_cassette.http_interactions.remaining_unused_interaction_count
+        return [] if num_remaining_interactions.zero?
+
+        interaction_description = if num_remaining_interactions == 1
+          "1 HTTP interaction that has"
+        else
+          "#{num_remaining_interactions} HTTP interactions that have"
+        end
+
+        description_lines, link = suggestion_for(:match_requests_on)
+        description_lines[0] = description_lines[0] % interaction_description
+        [[description_lines, link]]
+      end
+
     end
   end
 end

data/lib/vcr/library_hooks.rb

@@ -1,18 +1,16 @@
 module VCR
   class LibraryHooks
-    def initialize
-      @exclusive_hook = nil
-    end
+    attr_accessor :exclusive_hook
 
     def disabled?(hook)
-      ![nil, hook].include?(@exclusive_hook)
+      ![nil, hook].include?(exclusive_hook)
     end
 
     def exclusively_enabled(hook)
-      @exclusive_hook = hook
+      self.exclusive_hook = hook
       yield
     ensure
-      @exclusive_hook = nil
+      self.exclusive_hook = nil
     end
   end
 end

data/lib/vcr/library_hooks/excon.rb

@@ -2,7 +2,7 @@ require 'vcr/util/version_checker'
 require 'vcr/request_handler'
 require 'excon'
 
-VCR::VersionChecker.new('Excon', Excon::VERSION, '0.6.5', '0.6').check_version!
+VCR::VersionChecker.new('Excon', Excon::VERSION, '0.6.5', '0.7').check_version!
 
 module VCR
   class LibraryHooks
@@ -10,12 +10,20 @@ module VCR
       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_request
+          @vcr_response = stubbed_response
           {
             :body     => stubbed_response.body,
             :headers  => normalized_headers(stubbed_response.headers || {}),
@@ -23,6 +31,10 @@ module VCR
           }
         end
 
+        def on_ignored_request
+          perform_real_request
+        end
+
         def response_from_excon_error(error)
           if error.respond_to?(:response)
             error.response
@@ -34,20 +46,18 @@ module VCR
         end
 
         def perform_real_request
-          connection = ::Excon.new(uri)
-
-          response = begin
-            connection.request(params.merge(:mock => false))
-          rescue ::Excon::Errors::Error => e
-            yield response_from_excon_error(e) if block_given?
-            raise e
+          begin
+            response = ::Excon.new(uri).request(params.merge(:mock => false))
+          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
-        alias on_ignored_request perform_real_request
 
         def on_recordable_request
           perform_real_request do |response|
@@ -60,6 +70,8 @@ module VCR
           @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
@@ -84,7 +96,7 @@ module VCR
         def http_interaction_for(response)
           VCR::HTTPInteraction.new \
             vcr_request,
-            vcr_response(response)
+            vcr_response_from(response)
         end
 
         def vcr_request
@@ -100,7 +112,7 @@ module VCR
           end
         end
 
-        def vcr_response(response)
+        def vcr_response_from(response)
           VCR::Response.new \
             VCR::ResponseStatus.new(response.status, nil),
             response.headers,

data/lib/vcr/library_hooks/fakeweb.rb

@@ -3,6 +3,7 @@ require 'fakeweb'
 require 'net/http'
 require 'vcr/extensions/net_http_response'
 require 'vcr/request_handler'
+require 'set'
 
 VCR::VersionChecker.new('FakeWeb', FakeWeb::VERSION, '1.3.0', '1.3').check_version!
 
@@ -10,39 +11,84 @@ module VCR
   class LibraryHooks
     module FakeWeb
       class RequestHandler < ::VCR::RequestHandler
-        attr_reader :net_http, :request, :request_body, :block
-        def initialize(net_http, request, request_body = nil, &block)
-          @net_http, @request, @request_body, @block =
-           net_http,  request,  request_body,  block
+        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
         end
 
-      private
+        def handle
+          super
+        ensure
+          invoke_after_request_hook(@vcr_response) unless @recursing
+        end
 
-        def perform_and_record_request
-          # Net::HTTP calls #request recursively in certain circumstances.
-          # We only want to record hte request when the request is started, as
-          # that is the final time through #request.
-          return perform_request unless net_http.started?
+        class << self
+          def already_seen_requests
+            @already_seen_requests ||= Set.new
+          end
+        end
 
-          perform_request do |response|
-            VCR.record_http_interaction VCR::HTTPInteraction.new(vcr_request, vcr_response_from(response))
-            response.extend VCR::Net::HTTPResponse # "unwind" the response
-            block.call(response) if block
+      private
+
+        def invoke_before_request_hook
+          unless self.class.already_seen_requests.include?(request.object_id)
+            super
+            # we use the object_id so that if there is bug that causes
+            # us not to fully cleanup, we'll only be leaking the memory
+            # of one integer, not the whole request object.
+            self.class.already_seen_requests << request.object_id
           end
         end
-        alias on_recordable_request perform_and_record_request
 
-        def perform_stubbed_request
+        def invoke_after_request_hook(vcr_response)
+          self.class.already_seen_requests.delete(request.object_id)
+          super
+        end
+
+        def on_recordable_request
+          perform_request(net_http.started?, :record_interaction)
+        end
+
+        def on_stubbed_request
           with_exclusive_fakeweb_stub(stubbed_response) do
-            perform_request
+            # force it to be considered started since it doesn't
+            # recurse in this case like the others.
+            perform_request(:started)
           end
         end
-        alias on_stubbed_request perform_stubbed_request
 
-        def perform_request(&record_block)
-          net_http.request_without_vcr(request, request_body, &(record_block || block))
+        def on_ignored_request
+          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
+          # that is the final time through #request.
+          unless started
+            @recursing = true
+            return net_http.request_without_vcr(request, request_body, &response_block)
+          end
+
+          net_http.request_without_vcr(request, request_body) do |response|
+            @vcr_response = vcr_response_from(response)
+
+            if record_interaction
+              VCR.record_http_interaction VCR::HTTPInteraction.new(vcr_request, @vcr_response)
+            end
+
+            response.extend VCR::Net::HTTPResponse # "unwind" the response
+            response_block.call(response) if response_block
+          end
         end
-        alias on_ignored_request perform_request
 
         def uri
           @uri ||= ::FakeWeb::Utility.request_uri_as_string(net_http, request)
@@ -91,9 +137,13 @@ module Net
   class HTTP
     unless method_defined?(:request_with_vcr)
       def request_with_vcr(*args, &block)
-        VCR::LibraryHooks::FakeWeb::RequestHandler.new(
-          self, *args, &block
-        ).handle
+        if VCR.turned_on?
+          VCR::LibraryHooks::FakeWeb::RequestHandler.new(
+            self, *args, &block
+          ).handle
+        else
+          request_without_vcr(*args, &block)
+        end
       end
 
       alias request_without_vcr request
@@ -102,6 +152,17 @@ 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
+
+  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?)
+
 VCR.configuration.after_library_hooks_loaded do
   if defined?(WebMock)
     raise ArgumentError.new("You have configured VCR to hook into both :fakeweb and :webmock. You cannot use both.")