vcr 1.4.0 → 1.5.0

data/lib/vcr/deprecations.rb

@@ -1,5 +1,5 @@
 module VCR
-  class Config
+  module Config
     class << self
       def http_stubbing_library
         warn "WARNING: `VCR::Config.http_stubbing_library` is deprecated.  Use `VCR::Config.http_stubbing_libraries` instead."

data/lib/vcr/extensions/net_http.rb

@@ -11,7 +11,12 @@ module Net
       vcr_request = VCR::Request.from_net_http_request(self, request)
       response = request_without_vcr(request, body)
 
-      match_attributes = (cass = VCR.current_cassette) ? cass.match_requests_on : VCR::RequestMatcher::DEFAULT_MATCH_ATTRIBUTES
+      match_attributes = if cass = VCR.current_cassette
+        cass.match_requests_on
+      else
+        VCR::RequestMatcher::DEFAULT_MATCH_ATTRIBUTES
+      end
+
       if started? && !VCR.http_stubbing_adapter.request_stubbed?(vcr_request, match_attributes)
         VCR.record_http_interaction VCR::HTTPInteraction.new(vcr_request, VCR::Response.from_net_http_response(response))
         response.extend VCR::Net::HTTPResponse # "unwind" the response

data/lib/vcr/hooks.rb

@@ -0,0 +1,45 @@
+module VCR
+  module Hooks
+    def invoke_hook(hook, tag, *args)
+      hooks_for(hook, tag).each do |callback|
+        callback.call(*args_for_callback(args, callback))
+      end
+    end
+
+    def clear_hooks
+      hooks.clear
+    end
+
+    private
+
+      def hooks
+        @hooks ||= Hash.new do |hook_type_hash, hook_type|
+          hook_type_hash[hook_type] = Hash.new do |tag_hash, tag|
+            tag_hash[tag] = []
+          end
+        end
+      end
+
+      def define_hook(hook)
+        # We must use string eval so that the dynamically
+        # defined method can accept a block.
+        instance_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{hook}(tag = nil, &block)
+            hooks[#{hook.inspect}][tag] << block
+          end
+        RUBY
+      end
+
+      def hooks_for(hook, tag)
+        for_hook = hooks[hook]
+        hooks = for_hook[tag] # matching tagged hooks
+        hooks += for_hook[nil] unless tag.nil? # untagged hooks
+        hooks
+      end
+
+      def args_for_callback(args, callback)
+        return args if callback.arity < 0
+        args.first([args.size, callback.arity].min)
+      end
+  end
+end

data/lib/vcr/http_stubbing_adapters/common.rb

@@ -47,12 +47,11 @@ module VCR
       end
 
       def check_version!
-        version_too_low, version_too_high = compare_version
-
-        if version_too_low
-          raise "You are using #{library_name} #{version}.  VCR requires version #{version_requirement}."
-        elsif version_too_high
-          warn "You are using #{library_name} #{version}.  VCR is known to work with #{library_name} #{version_requirement}.  It may not work with this version."
+        case compare_version
+          when :too_low
+            raise "You are using #{library_name} #{version}.  VCR requires version #{version_requirement}."
+          when :too_high
+            warn "You are using #{library_name} #{version}.  VCR is known to work with #{library_name} #{version_requirement}.  It may not work with this version."
         end
       end
 
@@ -64,6 +63,10 @@ module VCR
         self.http_connections_allowed = VCR::Config.allow_http_connections_when_no_cassette?
       end
 
+      def restore_stubs_checkpoint(cassette)
+        raise ArgumentError.new("No checkpoint for #{cassette.inspect} could be found")
+      end
+
       private
 
       def compare_version
@@ -71,13 +74,13 @@ module VCR
         min_major, min_minor, min_patch = parse_version(self::MINIMUM_VERSION)
         max_major, max_minor            = parse_version(self::MAXIMUM_VERSION)
 
-        return true, false if major < min_major
-        return false, true if major > max_major
-
-        return true, false if minor < min_minor
-        return false, true if minor > max_minor
-
-        return patch < min_patch, false
+        case
+          when major < min_major; :too_low
+          when major > max_major; :too_high
+          when minor < min_minor; :too_low
+          when minor > max_minor; :too_high
+          when patch < min_patch; :too_low
+        end
       end
 
       def version_requirement

data/lib/vcr/http_stubbing_adapters/fakeweb.rb

@@ -43,12 +43,12 @@ module VCR
         end
       end
 
-      def create_stubs_checkpoint(checkpoint_name)
-        checkpoints[checkpoint_name] = ::FakeWeb::Registry.instance.uri_map.dup
+      def create_stubs_checkpoint(cassette)
+        checkpoints[cassette] = ::FakeWeb::Registry.instance.uri_map.dup
       end
 
-      def restore_stubs_checkpoint(checkpoint_name)
-        ::FakeWeb::Registry.instance.uri_map = checkpoints.delete(checkpoint_name)
+      def restore_stubs_checkpoint(cassette)
+        ::FakeWeb::Registry.instance.uri_map = checkpoints.delete(cassette) || super
       end
 
       def request_stubbed?(request, match_attributes)

data/lib/vcr/http_stubbing_adapters/faraday.rb

@@ -26,12 +26,12 @@ module VCR
         end
       end
 
-      def create_stubs_checkpoint(checkpoint_name)
-        checkpoints[checkpoint_name] = stub_queue_dup
+      def create_stubs_checkpoint(cassette)
+        checkpoints[cassette] = stub_queue_dup
       end
 
-      def restore_stubs_checkpoint(checkpoint_name)
-        @stub_queues = checkpoints.delete(checkpoint_name)
+      def restore_stubs_checkpoint(cassette)
+        @stub_queues = checkpoints.delete(cassette) || super
       end
 
       def stubbed_response_for(request_matcher)

data/lib/vcr/http_stubbing_adapters/typhoeus.rb

@@ -43,12 +43,12 @@ module VCR
         end
       end
 
-      def create_stubs_checkpoint(checkpoint_name)
-        checkpoints[checkpoint_name] = ::Typhoeus::Hydra.stubs.dup
+      def create_stubs_checkpoint(cassette)
+        checkpoints[cassette] = ::Typhoeus::Hydra.stubs.dup
       end
 
-      def restore_stubs_checkpoint(checkpoint_name)
-        ::Typhoeus::Hydra.stubs = checkpoints.delete(checkpoint_name)
+      def restore_stubs_checkpoint(cassette)
+        ::Typhoeus::Hydra.stubs = checkpoints.delete(cassette) || super
       end
 
       private

data/lib/vcr/http_stubbing_adapters/webmock.rb

@@ -36,12 +36,12 @@ module VCR
         end
       end
 
-      def create_stubs_checkpoint(checkpoint_name)
-        checkpoints[checkpoint_name] = ::WebMock::StubRegistry.instance.request_stubs.dup
+      def create_stubs_checkpoint(cassette)
+        checkpoints[cassette] = ::WebMock::StubRegistry.instance.request_stubs.dup
       end
 
-      def restore_stubs_checkpoint(checkpoint_name)
-        ::WebMock::StubRegistry.instance.request_stubs = checkpoints.delete(checkpoint_name)
+      def restore_stubs_checkpoint(cassette)
+        ::WebMock::StubRegistry.instance.request_stubs = checkpoints.delete(cassette) || super
       end
 
       private

data/lib/vcr/structs.rb

@@ -157,5 +157,13 @@ module VCR
   class HTTPInteraction < Struct.new(:request, :response)
     extend ::Forwardable
     def_delegators :request, :uri, :method
+
+    def ignore!
+      @ignored = true
+    end
+
+    def ignored?
+      @ignored
+    end
   end
 end

data/lib/vcr/{internet_connection.rb → util/internet_connection.rb}

@@ -1,4 +1,4 @@
-require 'vcr/ping'
+require 'vcr/util/ping'
 
 module VCR
   module InternetConnection

data/lib/vcr/version.rb

@@ -3,7 +3,7 @@ module VCR
 
   def version
     @version ||= begin
-      string = '1.4.0'
+      string = '1.5.0'
 
       def string.parts; VCR.version.split('.').map { |p| p.to_i }; end
       def string.major; parts[0]; end

data/script/FullBuildRakeFile

@@ -7,6 +7,12 @@ task :build => :ensure_bundler_installed do
   sh "rake"
 end
 
+desc "Install necessary gems with bundler, runs specs, run cukes"
+task :spec => :ensure_bundler_installed do
+  sh "bundle install"
+  sh "rake spec"
+end
+
 task :ensure_bundler_installed do
   installed = begin
     require 'rubygems'

data/script/full_build

@@ -1 +1 @@
-rvm 1.8.6,1.8.7,1.9.1,1.9.2,ree,jruby,rbx rake -f script/FullBuildRakeFile build | tee tmp/full_build.out
+rvm 1.8.6,1.8.7,1.9.1,1.9.2,ree,rbx rake -f script/FullBuildRakeFile build && rvm use jruby && bundle install && rake | tee tmp/full_build.out

data/script/spec

@@ -0,0 +1 @@
+rvm 1.8.6,1.8.7,1.9.1,1.9.2,ree,rbx rake -f script/FullBuildRakeFile spec && rvm use jruby && bundle install && rake spec | tee tmp/spec.out

data/spec/spec_helper.rb

@@ -7,13 +7,15 @@ require 'rspec'
 # Ruby 1.9.1 has a different yaml serialization format.
 YAML_SERIALIZATION_VERSION = RUBY_VERSION == '1.9.1' ? '1.9.1' : 'not_1.9.1'
 
-# Requires supporting files with custom matchers and macros, etc,
-# in ./support/ and its subdirectories.
-Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require File.join("support", File.basename(f))}
+Dir['./spec/support/**/*.rb'].each { |f| require f }
 
 require 'vcr'
 require 'monkey_patches'
 
+module VCR
+  SPEC_ROOT = File.dirname(__FILE__)
+end
+
 RSpec.configure do |config|
   config.extend TempCassetteLibraryDir
   config.extend DisableWarnings
@@ -21,7 +23,7 @@ RSpec.configure do |config|
   config.extend WebMockMacros
 
   config.color_enabled = true
-  config.debug = RUBY_INTERPRETER == :mri
+  config.debug = RUBY_INTERPRETER == :mri && RUBY_VERSION != '1.9.2'
 
   config.before(:each) do
     VCR.turn_on! unless VCR.turned_on?
@@ -29,6 +31,7 @@ RSpec.configure do |config|
 
     VCR::Config.default_cassette_options = { :record => :new_episodes }
     VCR::Config.stub_with :fakeweb
+    VCR::Config.clear_hooks
 
     WebMock.allow_net_connect!
     WebMock.reset!

data/spec/support/http_library_adapters.rb

@@ -331,6 +331,14 @@ module HttpLibrarySpecs
         subject.http_connections_allowed?.should == false
       end
 
+      describe '.restore_stubs_checkpoint' do
+        it 'raises an appropriate error when there is no matching checkpoint' do
+          expect {
+            subject.restore_stubs_checkpoint(:some_crazy_checkpoint_that_doesnt_exist)
+          }.to raise_error(ArgumentError, /no checkpoint .* could be found/i)
+        end
+      end
+
       [true, false].each do |http_allowed|
         context "when #http_connections_allowed is set to #{http_allowed}" do
           before(:each) { subject.http_connections_allowed = http_allowed }

data/spec/support/http_stubbing_adapter.rb

@@ -52,9 +52,9 @@ shared_examples_for "an http stubbing adapter" do |supported_http_libraries, sup
     end
 
     it 're-enables all adapters afterwards' do
-      VCR::HttpStubbingAdapters::Common.adapters.all? { |a| a.should be_enabled }
+      VCR::HttpStubbingAdapters::Common.adapters.each { |a| a.should be_enabled }
       subject.exclusively_enabled { }
-      VCR::HttpStubbingAdapters::Common.adapters.all? { |a| a.should be_enabled }
+      VCR::HttpStubbingAdapters::Common.adapters.each { |a| a.should be_enabled }
     end
   end
 

data/spec/vcr/cassette/reader_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe VCR::Cassette::Reader do
+  describe '#read' do
+    def read(*args)
+      described_class.new(*args).read
+    end
+
+    let(:no_vars_content) { '<%= 3 + 4 %>. Some ERB' }
+    let(:vars_content) { '<%= var1 %>. ERB with Vars! <%= var2 %>' }
+
+    before(:each) do
+      File.stub(:read) do |name|
+        case name
+          when 'no_vars'; no_vars_content
+          when 'vars'; vars_content
+          else raise ArgumentError.new("Unexpected file name: #{name}")
+        end
+      end
+    end
+
+    context 'when ERB is disabled' do
+      it 'reads the raw file content' do
+        read('no_vars', false).should == no_vars_content
+        read('no_vars', nil).should == no_vars_content
+      end
+    end
+
+    context 'when ERB is enabled but no variables are passed' do
+      it 'renders the file content as ERB' do
+        read('no_vars', true).should == "7. Some ERB"
+      end
+
+      it 'raises an appropriate error when the ERB template needs variables' do
+        expect {
+          read('vars', true)
+        }.to raise_error(VCR::Cassette::MissingERBVariableError,
+          %{The ERB in the vars cassette file references undefined variable var1.  } +
+          %{Pass it to the cassette using :erb => #{ {:var1=>"some value"}.inspect }.}
+        )
+      end
+    end
+
+    context 'when ERB is enabled and variables are passed' do
+      it 'renders the file content as ERB with the passed variables' do
+        read('vars', :var1 => 'foo', :var2 => 'bar').should == 'foo. ERB with Vars! bar'
+      end
+
+      it 'raises an appropriate error when one or more of the needed variables are not passed' do
+        expect {
+          read('vars', :var1 => 'foo')
+        }.to raise_error(VCR::Cassette::MissingERBVariableError,
+          %{The ERB in the vars cassette file references undefined variable var2.  } +
+          %{Pass it to the cassette using :erb => #{ {:var1 => "foo", :var2 => "some value"}.inspect }.}
+        )
+      end
+    end
+  end
+end

data/spec/{cassette_spec.rb → vcr/cassette_spec.rb}

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe VCR::Cassette do
   describe '#file' do
-    temp_dir File.expand_path(File.dirname(__FILE__) + '/fixtures/file'), :assign_to_cassette_library_dir => true
+    temp_dir "#{VCR::SPEC_ROOT}/fixtures/file", :assign_to_cassette_library_dir => true
 
     it 'combines the cassette_library_dir with the cassette name' do
       cassette = VCR::Cassette.new('the_file')
@@ -51,7 +51,7 @@ describe VCR::Cassette do
 
   describe 'on creation' do
     it 'raises an error with a helpful message when loading an old unsupported cassette' do
-      VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{YAML_SERIALIZATION_VERSION}")
+      VCR::Config.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}"
       expect { VCR::Cassette.new('0_3_1_cassette') }.to raise_error(/The VCR cassette 0_3_1_cassette.yml uses an old format that is now deprecated/)
     end
 
@@ -65,63 +65,56 @@ describe VCR::Cassette do
       }.to raise_error(ArgumentError)
     end
 
-    it 'creates a stubs checkpoint on the http_stubbing_adapter' do
-      VCR.http_stubbing_adapter.should_receive(:create_stubs_checkpoint).with('example').once
-      VCR::Cassette.new('example')
+    it 'does not raise an error in the case of an empty file' do
+      VCR::Config.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec"
+      VCR::Cassette.new('empty', :record => :none).recorded_interactions.should == []
     end
 
-    describe 'ERB support' do
-      before(:each) do
-        @orig_default_options = VCR::Config.default_cassette_options
-      end
+    it 'creates a stubs checkpoint on the http_stubbing_adapter' do
+      cassette = nil
 
-      after(:each) do
-        VCR::Config.default_cassette_options = @orig_default_options
+      VCR.http_stubbing_adapter.should_receive(:create_stubs_checkpoint) do |c|
+        cassette = c
       end
 
-      def cassette_body(name, options = {})
-        VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec")
-        VCR::Cassette.new(name, options.merge(:record => :new_episodes)).recorded_interactions.first.response.body
-      end
+      VCR::Cassette.new('example').should equal(cassette)
+    end
 
-      it "compiles a template as ERB if the :erb option is passed as true" do
-        cassette_body('erb_with_no_vars', :erb => true).should == 'sum: 3'
+    describe "reading the file from disk" do
+      before(:each) do
+        VCR::Config.cassette_library_dir = "cassette_lib"
+        File.stub(:size? => true)
       end
 
-      it "compiles a template as ERB if the default :erb option is true, and no option is passed to the cassette" do
-        VCR::Config.default_cassette_options = { :erb => true }
-        cassette_body('erb_with_no_vars').should == 'sum: 3'
-      end
+      it 'reads the appropriate file from disk using a VCR::Cassette::Reader' do
+        VCR::Cassette::Reader.should_receive(:new).with(
+          'cassette_lib/foo.yml', anything
+        ).and_return(mock('reader', :read => [].to_yaml))
 
-      it "does not compile a template as ERB if the default :erb option is true, and :erb => false is passed to the cassette" do
-        VCR::Config.default_cassette_options = { :erb => true }
-        cassette_body('erb_with_no_vars', :erb => false).should == 'sum: <%= 1 + 2 %>'
+        VCR::Cassette.new('foo', :record => :new_episodes)
       end
 
-      it "compiles a template as ERB if the :erb option is passed a hash" do
-        cassette_body('erb_with_vars', :erb => { :var1 => 'a', :var3 => 'c', :var2 => 'b' }).should == 'var1: a; var2: b; var3: c'
-      end
+      [true, false, nil, { }].each do |erb|
+        it "passes #{erb.inspect} to the VCR::Cassette::Reader when given as the :erb option" do
+          # test that it overrides the default
+          VCR::Config.default_cassette_options = { :erb => true }
 
-      it "does not compile a template as ERB if the :erb option is not used" do
-        cassette_body('erb_with_no_vars').should == 'sum: <%= 1 + 2 %>'
-      end
+          VCR::Cassette::Reader.should_receive(:new).with(
+            anything, erb
+          ).and_return(mock('reader', :read => [].to_yaml))
 
-      it "raises a helpful error if the ERB template references variables that are not passed in the :erb hash" do
-        expect {
-          cassette_body('erb_with_vars', :erb => { :var1 => 'a', :var2 => 'b' })
-        }.to raise_error(VCR::Cassette::MissingERBVariableError,
-          %{The ERB in the erb_with_vars.yml cassette file references undefined variable var3.  } +
-          %{Pass it to the cassette using :erb => #{ { :var1 => 'a', :var2 => 'b' }.merge(:var3 => 'some value').inspect }.}
-        )
-      end
+          VCR::Cassette.new('foo', :record => :new_episodes, :erb => erb)
+        end
+
+        it "passes #{erb.inspect} to the VCR::Cassette::Reader when it is the default :erb option and none is given" do
+          VCR::Config.default_cassette_options = { :erb => erb }
 
-      it "raises a helpful error if the ERB template references variables and :erb => true is passed" do
-        expect {
-          cassette_body('erb_with_vars', :erb => true)
-        }.to raise_error(VCR::Cassette::MissingERBVariableError,
-          %{The ERB in the erb_with_vars.yml cassette file references undefined variable var1.  } +
-          %{Pass it to the cassette using :erb => {:var1=>"some value"}.}
-        )
+          VCR::Cassette::Reader.should_receive(:new).with(
+            anything, erb
+          ).and_return(mock('reader', :read => [].to_yaml))
+
+          VCR::Cassette.new('foo', :record => :new_episodes)
+        end
       end
     end
 
@@ -194,14 +187,14 @@ describe VCR::Cassette do
 
           it "#{ ignore_localhost ? 'does not load' : 'loads' } localhost interactions from the cassette file when http_stubbing_adapter.ignore_localhost is set to #{ignore_localhost}" do
             VCR.http_stubbing_adapter.stub!(:ignore_localhost?).and_return(ignore_localhost)
-            VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec")
+            VCR::Config.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec"
             cassette = VCR::Cassette.new('with_localhost_requests', :record => record_mode)
             cassette.recorded_interactions.map { |i| URI.parse(i.uri).host }.should =~ expected_uri_hosts
           end
         end
 
         it "loads the recorded interactions from the library yml file" do
-          VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec")
+          VCR::Config.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec"
           cassette = VCR::Cassette.new('example', :record => record_mode)
 
           cassette.should have(3).recorded_interactions
@@ -222,20 +215,42 @@ describe VCR::Cassette do
         end
 
         if stub_requests
+          it 'invokes the appropriately tagged before_playback hooks' do
+            VCR::Config.should_receive(:invoke_hook).with(
+              :before_playback,
+              :foo,
+              an_instance_of(VCR::HTTPInteraction),
+              an_instance_of(VCR::Cassette)
+            ).exactly(3).times
+
+            cassette = VCR::Cassette.new('example', :record => record_mode, :tag => :foo)
+            cassette.should have(3).recorded_interactions
+          end
+
+          it 'does not playback any interactions that are ignored in a before_playback hook' do
+            VCR.config do |c|
+              c.before_playback { |i| i.ignore! if i.request.uri =~ /foo/ }
+            end
+
+            VCR::Config.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec"
+            cassette = VCR::Cassette.new('example', :record => record_mode)
+            cassette.should have(2).recorded_interactions
+          end
+
           it "stubs the recorded requests with the http stubbing adapter" do
-            VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec")
+            VCR::Config.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec"
             VCR.http_stubbing_adapter.should_receive(:stub_requests).with([an_instance_of(VCR::HTTPInteraction)]*3, anything)
             cassette = VCR::Cassette.new('example', :record => record_mode)
           end
 
           it "passes the :match_request_on option to #stub_requests" do
-            VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec")
+            VCR::Config.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec"
             VCR.http_stubbing_adapter.should_receive(:stub_requests).with(anything, [:body, :headers])
             cassette = VCR::Cassette.new('example', :record => record_mode, :match_requests_on => [:body, :headers])
           end
         else
           it "does not stub the recorded requests with the http stubbing adapter" do
-            VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec")
+            VCR::Config.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec"
             VCR.http_stubbing_adapter.should_not_receive(:stub_requests)
             cassette = VCR::Cassette.new('example', :record => record_mode)
           end
@@ -245,7 +260,7 @@ describe VCR::Cassette do
   end
 
   describe '#eject' do
-    temp_dir File.expand_path(File.dirname(__FILE__) + '/fixtures/cassette_spec_eject'), :assign_to_cassette_library_dir => true
+    temp_dir "#{VCR::SPEC_ROOT}/fixtures/cassette_spec_eject", :assign_to_cassette_library_dir => true
 
     [true, false].each do |orig_http_connections_allowed|
       it "resets #{orig_http_connections_allowed} on the http stubbing adapter if it was originally #{orig_http_connections_allowed}" do
@@ -271,6 +286,52 @@ describe VCR::Cassette do
       saved_recorded_interactions.should == recorded_interactions
     end
 
+    it 'invokes the appropriately tagged before_record hooks' do
+      interactions = [
+        VCR::HTTPInteraction.new(:req_sig_1, :response_1),
+        VCR::HTTPInteraction.new(:req_sig_2, :response_2)
+      ]
+
+      cassette = VCR::Cassette.new('example', :tag => :foo)
+      cassette.stub!(:new_recorded_interactions).and_return(interactions)
+
+      interactions.each do |i|
+        VCR::Config.should_receive(:invoke_hook).with(
+          :before_record,
+          :foo,
+          i,
+          cassette
+        ).ordered
+      end
+
+      cassette.eject
+    end
+
+    it 'does not record interactions that have been ignored' do
+      interaction_1 = VCR::HTTPInteraction.new(:request_1, :response_1)
+      interaction_2 = VCR::HTTPInteraction.new(:request_2, :response_2)
+
+      interaction_1.ignore!
+
+      cassette = VCR::Cassette.new('test_cassette')
+      cassette.stub!(:new_recorded_interactions).and_return([interaction_1, interaction_2])
+      cassette.eject
+
+      saved_recorded_interactions = YAML.load_file(cassette.file)
+      saved_recorded_interactions.should == [interaction_2]
+    end
+
+    it 'does not write the cassette to disk if all interactions have been ignored' do
+      interaction_1 = VCR::HTTPInteraction.new(:request_1, :response_1)
+      interaction_1.ignore!
+
+      cassette = VCR::Cassette.new('test_cassette')
+      cassette.stub!(:new_recorded_interactions).and_return([interaction_1])
+      cassette.eject
+
+      File.should_not exist(cassette.file)
+    end
+
     it "writes the recorded interactions to a subdirectory if the cassette name includes a directory" do
       recorded_interactions = [VCR::HTTPInteraction.new(:the_request, :the_response)]
       cassette = VCR::Cassette.new('subdirectory/test_cassette')
@@ -283,17 +344,17 @@ describe VCR::Cassette do
 
     [:all, :none, :new_episodes].each do |record_mode|
       context "for a :record => :#{record_mode} cassette with previously recorded interactions" do
-        temp_dir File.expand_path(File.dirname(__FILE__) + "/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec/temp"), :assign_to_cassette_library_dir => true
+        temp_dir "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec/temp", :assign_to_cassette_library_dir => true
 
         subject { VCR::Cassette.new('example', :record => record_mode, :match_requests_on => [:uri]) }
 
         before(:each) do
-          base_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec")
+          base_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec"
           FileUtils.cp(base_dir + "/example.yml", base_dir + "/temp/example.yml")
         end
 
         it "restore the stubs checkpoint on the http stubbing adapter" do
-          VCR.http_stubbing_adapter.should_receive(:restore_stubs_checkpoint).with('example')
+          VCR.http_stubbing_adapter.should_receive(:restore_stubs_checkpoint).with(subject)
           subject.eject
         end