vcr 1.11.3 → 2.0.0.beta1

data/spec/support/shared_example_groups/version_checking.rb

@@ -1,28 +1,28 @@
-shared_examples_for "version checking" do |options|
-  library = described_class.library_name
+shared_examples_for "version checking" do |library, options|
+  file = options[:file] || "vcr/library_hooks/#{library.downcase}.rb"
 
-  describe '.check_version!', :disable_warnings => true do
+  context 'when loading the library hook file', :disable_warnings => true do
     options[:valid].each do |version|
       it "does nothing when #{library}'s version is #{version}" do
         stub_version(version)
-        described_class.should_not_receive(:warn)
-        expect { described_class.check_version! }.to_not raise_error
+        Kernel.should_not_receive(:warn)
+        expect { load file }.to_not raise_error
       end
     end
 
     options[:too_low].each do |version|
       it "raises an error when #{library}'s version is #{version}" do
         stub_version(version)
-        described_class.should_not_receive(:warn)
-        expect { described_class.check_version! }.to raise_error(/You are using #{library} #{version}.  VCR requires version/)
+        Kernel.should_not_receive(:warn)
+        expect { load file }.to raise_error(/You are using #{library} #{version}. VCR requires version/)
       end
     end
 
     options[:too_high].each do |version|
       it "does nothing when #{library}'s version is #{version}" do
         stub_version(version)
-        described_class.should_receive(:warn).with(/VCR is known to work with #{library}/)
-        expect { described_class.check_version! }.to_not raise_error
+        Kernel.should_receive(:warn).with(/VCR is known to work with #{library}/)
+        expect { load file }.to_not raise_error
       end
     end
   end

data/spec/vcr/cassette/http_interaction_list_spec.rb

@@ -0,0 +1,178 @@
+require 'vcr/cassette/http_interaction_list'
+require 'vcr/request_matcher_registry'
+require 'vcr/structs/http_interaction'
+require 'uri'
+
+module VCR
+  class Cassette
+
+    shared_examples_for "an HTTP interaction finding method" do |method|
+      it 'returns nil when the list is empty' do
+        HTTPInteractionList.new([], [:method]).send(method, stub).should respond_with(nil)
+      end
+
+      it 'returns nil when there is no matching interaction' do
+        HTTPInteractionList.new([
+          interaction('foo', :method => :post),
+          interaction('foo', :method => :put)
+        ], [:method]).send(method,
+          request_with(:method => :get)
+        ).should respond_with(nil)
+      end
+
+      it 'returns the first matching interaction' do
+        list = HTTPInteractionList.new([
+          interaction('put response', :method => :put),
+          interaction('post response 1', :method => :post),
+          interaction('post response 2', :method => :post)
+        ], [:method])
+
+        list.send(method, request_with(:method => :post)).should respond_with("post response 1")
+      end
+
+      it 'invokes each matcher block to find the matching interaction' do
+        VCR.request_matchers.register(:foo) { |r1, r2| true }
+        VCR.request_matchers.register(:bar) { |r1, r2| true }
+
+        calls = 0
+        VCR.request_matchers.register(:baz) { |r1, r2| calls += 1; calls == 2 }
+
+        list = HTTPInteractionList.new([
+          interaction('response', :method => :put)
+        ], [:foo, :bar, :baz])
+
+        list.send(method, request_with(:method => :post)).should respond_with(nil)
+        list.send(method, request_with(:method => :post)).should respond_with('response')
+      end
+
+      it "delegates to the parent list when it can't find a matching interaction" do
+        parent_list = mock(method => response('parent'))
+        HTTPInteractionList.new(
+          [], [:method], false, parent_list
+        ).send(method, stub).should respond_with('parent')
+      end
+    end
+
+    describe HTTPInteractionList do
+      before(:each) do
+        VCR.stub(:request_matchers => VCR::RequestMatcherRegistry.new)
+      end
+
+      def request_with(values)
+        VCR::Request.new.tap do |request|
+          values.each do |name, value|
+            request.send("#{name}=", value)
+          end
+        end
+      end
+
+      def response(body)
+        VCR::Response.new.tap { |r| r.body = body }
+      end
+
+      def interaction(body, request_values)
+        VCR::HTTPInteraction.new \
+          request_with(request_values),
+          response(body)
+      end
+
+      let(:original_list_array) do [
+        interaction('put response', :method => :put),
+        interaction('post response 1', :method => :post),
+        interaction('post response 2', :method => :post)
+      ] end
+
+      let(:allow_playback_repeats) { false } # the default
+      let(:list) { HTTPInteractionList.new(original_list_array, [:method], allow_playback_repeats) }
+
+      describe "#has_interaction_matching?" do
+        it_behaves_like "an HTTP interaction finding method", :has_interaction_matching? do
+          def respond_with(value)
+            ::RSpec::Matchers::Matcher.new :respond_with, value do |expected|
+              match { |a| expected ? a : !a }
+            end
+          end
+        end
+
+        it 'does not consume the first matching interaction' do
+          10.times do
+            list.has_interaction_matching?(request_with(:method => :post)).should be_true
+          end
+          list.response_for(request_with(:method => :post)).body.should eq("post response 1")
+        end
+
+        context 'when allow_playback_repeats is set to false' do
+          let(:allow_playback_repeats) { false }
+
+          it 'returns false when there is a used (but no unused) matching interactions' do
+            list.response_for(request_with(:method => :put))
+
+            10.times.map {
+              list.has_interaction_matching?(request_with(:method => :put))
+            }.should eq([false] * 10)
+          end
+        end
+
+        context 'when allow_playback_repeats is set to true' do
+          let(:allow_playback_repeats) { true }
+
+          it 'returns true when there is a used (but no unused) matching interactions' do
+            list.response_for(request_with(:method => :put))
+
+            10.times.map {
+              list.has_interaction_matching?(request_with(:method => :put))
+            }.should eq([true] * 10)
+          end
+        end
+      end
+
+      describe "#response_for" do
+        it_behaves_like "an HTTP interaction finding method", :response_for do
+          def respond_with(value)
+            ::RSpec::Matchers::Matcher.new :respond_with, value do |expected|
+              match { |a| expected.nil? ? a.nil? : a.body == expected }
+            end
+          end
+        end
+
+        it 'consumes the first matching interaction so that it will not be used again' do
+          list.response_for(request_with(:method => :post)).body.should eq("post response 1")
+          list.response_for(request_with(:method => :post)).body.should eq("post response 2")
+        end
+
+        context 'when allow_playback_repeats is set to true' do
+          let(:allow_playback_repeats) { true }
+
+          it 'continues to return the response from the last matching interaction when there are no more' do
+            list.response_for(request_with(:method => :post))
+
+            10.times.map {
+              response = list.response_for(request_with(:method => :post))
+              response ? response.body : nil
+            }.should eq(["post response 2"] * 10)
+          end
+        end
+
+        context 'when allow_playback_repeats is set to false' do
+          let(:allow_playback_repeats) { false }
+
+          it 'returns nil when there are no more unused interactions' do
+            list.response_for(request_with(:method => :post))
+            list.response_for(request_with(:method => :post))
+
+            10.times.map {
+              list.response_for(request_with(:method => :post))
+            }.should eq([nil] * 10)
+          end
+        end
+
+        it 'does not modify the original interaction array the list was initialized with' do
+          original_dup = original_list_array.dup
+          list.response_for(request_with(:method => :post))
+          original_list_array.should == original_dup
+        end
+      end
+    end
+  end
+end
+

data/spec/vcr/cassette/reader_spec.rb

@@ -34,7 +34,7 @@ describe VCR::Cassette::Reader do
       it 'raises an appropriate error when the ERB template needs variables' do
         expect {
           read('vars', true)
-        }.to raise_error(VCR::Cassette::MissingERBVariableError,
+        }.to raise_error(VCR::Errors::MissingERBVariableError,
           %{The ERB in the vars cassette file references undefined variable var1.  } +
           %{Pass it to the cassette using :erb => #{ {:var1=>"some value"}.inspect }.}
         )
@@ -49,7 +49,7 @@ describe VCR::Cassette::Reader do
       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,
+        }.to raise_error(VCR::Errors::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 }.}
         )

data/spec/vcr/cassette_spec.rb

@@ -4,7 +4,7 @@ describe VCR::Cassette do
   describe '#file' do
     it 'combines the cassette_library_dir with the cassette name' do
       cassette = VCR::Cassette.new('the_file')
-      cassette.file.should eq(File.join(VCR::Config.cassette_library_dir, 'the_file.yml'))
+      cassette.file.should eq(File.join(VCR.configuration.cassette_library_dir, 'the_file.yml'))
     end
 
     it 'strips out disallowed characters so that it is a valid file name with no spaces' do
@@ -17,10 +17,12 @@ describe VCR::Cassette do
       cassette.file.should =~ /#{Regexp.escape('dir/file_name.yml')}$/
     end
 
-    it 'returns nil if the cassette_library_dir is not set' do
-      VCR::Config.cassette_library_dir = nil
-      cassette = VCR::Cassette.new('the_file')
-      cassette.file.should be_nil
+    VCR::Cassette::VALID_RECORD_MODES.each do |mode|
+      it "returns nil if the cassette_library_dir is not set (when the record mode is :#{mode})" do
+        VCR.configuration.cassette_library_dir = nil
+        cassette = VCR::Cassette.new('the_file', :record => mode)
+        cassette.file.should be_nil
+      end
     end
   end
 
@@ -33,8 +35,48 @@ describe VCR::Cassette do
     end
   end
 
+  describe "#recording?" do
+    [:all, :new_episodes].each do |mode|
+      it "returns true when the record mode is :#{mode}" do
+        cassette = VCR::Cassette.new("foo", :record => mode)
+        cassette.should be_recording
+      end
+    end
+
+    it "returns false when the record mode is :none" do
+      cassette = VCR::Cassette.new("foo", :record => :none)
+      cassette.should_not be_recording
+    end
+
+    context 'when the record mode is :once' do
+      before(:each) do
+        VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
+      end
+
+      it 'returns false when there is an existing cassette file with content' do
+        cassette = VCR::Cassette.new("example", :record => :once)
+        File.should exist(cassette.file)
+        File.size?(cassette.file).should be_true
+        cassette.should_not be_recording
+      end
+
+      it 'returns true when there is an empty existing cassette file' do
+        cassette = VCR::Cassette.new("empty", :record => :once)
+        File.should exist(cassette.file)
+        File.size?(cassette.file).should be_false
+        cassette.should be_recording
+      end
+
+      it 'returns true when there is no existing cassette file' do
+        cassette = VCR::Cassette.new("non_existant_file", :record => :once)
+        File.should_not exist(cassette.file)
+        cassette.should be_recording
+      end
+    end
+  end
+
   describe '#match_requests_on' do
-    before(:each) { VCR::Config.default_cassette_options.merge!(:match_requests_on => [:uri, :method]) }
+    before(:each) { VCR.configuration.default_cassette_options.merge!(:match_requests_on => [:uri, :method]) }
 
     it "returns the provided options" do
       c = VCR::Cassette.new('example', :match_requests_on => [:uri])
@@ -48,11 +90,6 @@ describe VCR::Cassette do
   end
 
   describe '.new' do
-    it 'raises an error with a helpful message when loading an old unsupported cassette' do
-      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
-
     it "raises an error if given an invalid record mode" do
       expect { VCR::Cassette.new(:test, :record => :not_a_record_mode) }.to raise_error(ArgumentError)
     end
@@ -64,20 +101,10 @@ describe VCR::Cassette do
     end
 
     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.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
       VCR::Cassette.new('empty', :record => :none).recorded_interactions.should eq([])
     end
 
-    it 'creates a stubs checkpoint on the http_stubbing_adapter' do
-      cassette = nil
-
-      VCR.http_stubbing_adapter.should_receive(:create_stubs_checkpoint) do |c|
-        cassette = c
-      end
-
-      VCR::Cassette.new('example').should equal(cassette)
-    end
-
     describe "reading the file from disk" do
       before(:each) do
         File.stub(:size? => true)
@@ -85,7 +112,7 @@ describe VCR::Cassette do
 
       it 'reads the appropriate file from disk using a VCR::Cassette::Reader' do
         VCR::Cassette::Reader.should_receive(:new).with(
-          "#{VCR::Config.cassette_library_dir}/foo.yml", anything
+          "#{VCR.configuration.cassette_library_dir}/foo.yml", anything
         ).and_return(mock('reader', :read => VCR::YAML.dump([])))
 
         VCR::Cassette.new('foo', :record => :new_episodes)
@@ -94,7 +121,7 @@ describe VCR::Cassette do
       [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 }
+          VCR.configuration.default_cassette_options = { :erb => true }
 
           VCR::Cassette::Reader.should_receive(:new).with(
             anything, erb
@@ -104,7 +131,7 @@ describe VCR::Cassette do
         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 }
+          VCR.configuration.default_cassette_options = { :erb => erb }
 
           VCR::Cassette::Reader.should_receive(:new).with(
             anything, erb
@@ -116,49 +143,23 @@ describe VCR::Cassette do
     end
 
     VCR::Cassette::VALID_RECORD_MODES.each do |record_mode|
-      http_connections_allowed = (record_mode != :none)
       stub_requests = (record_mode != :all)
 
-      context "when VCR::Config.default_cassette_options[:record] is :#{record_mode}" do
-        before(:each) { VCR::Config.default_cassette_options = { :record => record_mode } }
+      context "when VCR.configuration.default_cassette_options[:record] is :#{record_mode}" do
+        before(:each) { VCR.configuration.default_cassette_options = { :record => record_mode } }
 
-        it "defaults the record mode to #{record_mode} when VCR::Config.default_cassette_options[:record] is #{record_mode}" do
+        it "defaults the record mode to #{record_mode} when VCR.configuration.default_cassette_options[:record] is #{record_mode}" do
           cassette = VCR::Cassette.new(:test)
           cassette.record_mode.should eq(record_mode)
         end
       end
 
       context "when :#{record_mode} is passed as the record option" do
-        if record_mode == :none
-          it 'does not allow http connections when there is an existing cassette file with recorded interactions' do
-            VCR::Config.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec"
-            VCR.http_stubbing_adapter.should_receive(:http_connections_allowed=).with(false)
-            c = VCR::Cassette.new('example', :record => :once)
-            File.should exist(c.file)
-            File.size?(c.file).should be_true
-          end
-
-          it 'allows http connections when there is an empty existing cassette file' do
-            VCR::Config.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec"
-            VCR.http_stubbing_adapter.should_receive(:http_connections_allowed=).with(true)
-            c = VCR::Cassette.new('empty', :record => :once)
-            File.should exist(c.file)
-            File.size?(c.file).should be_false
-          end
-
-          it 'allows http connections when there is not an existing cassette file' do
-            VCR::Config.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec"
-            VCR.http_stubbing_adapter.should_receive(:http_connections_allowed=).with(true)
-            c = VCR::Cassette.new('non_existant_file', :record => :once)
-            File.should_not exist(c.file)
-          end
-        end
-
         unless record_mode == :all
           let(:interaction_1) { VCR::HTTPInteraction.new(VCR::Request.new(:get, 'http://example.com/'), VCR::Response.new(VCR::ResponseStatus.new)) }
           let(:interaction_2) { VCR::HTTPInteraction.new(VCR::Request.new(:get, 'http://example.com/'), VCR::Response.new(VCR::ResponseStatus.new)) }
           let(:interactions)  { [interaction_1, interaction_2] }
-          before(:each) { VCR::Config.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec" }
+          before(:each) { VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec" }
 
           it 'updates the content_length headers when given :update_content_length_header => true' do
             VCR::YAML.stub(:load => interactions)
@@ -179,7 +180,7 @@ describe VCR::Cassette do
           end
 
           context "and re_record_interval is 7.days" do
-            let(:file_name) { File.join(VCR::Config.cassette_library_dir, "cassette_name.yml") }
+            let(:file_name) { File.join(VCR.configuration.cassette_library_dir, "cassette_name.yml") }
             subject { VCR::Cassette.new(File.basename(file_name).gsub('.yml', ''), :record => record_mode, :re_record_interval => 7.days) }
 
             context 'when the cassette file does not exist' do
@@ -221,23 +222,18 @@ describe VCR::Cassette do
           end
         end
 
-        it "sets http_connections_allowed to #{http_connections_allowed} on the http stubbing adapter" do
-          VCR.http_stubbing_adapter.should_receive(:http_connections_allowed=).with(http_connections_allowed)
-          VCR::Cassette.new(:name, :record => record_mode)
-        end
-
         it 'does not load ignored interactions' do
-          VCR::Config.stub(:uri_should_be_ignored?) do |uri|
-            uri.to_s !~ /example\.com/
+          VCR.request_ignorer.stub(:ignore?) do |request|
+            request.uri !~ /example\.com/
           end
 
-          VCR::Config.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec"
+          VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
           cassette = VCR::Cassette.new('with_localhost_requests', :record => record_mode)
           cassette.recorded_interactions.map { |i| URI.parse(i.uri).host }.should eq(%w[example.com])
         end
 
         it "loads the recorded interactions from the library yml file" do
-          VCR::Config.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec"
+          VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
           cassette = VCR::Cassette.new('example', :record => record_mode)
 
           cassette.should have(3).recorded_interactions
@@ -257,9 +253,31 @@ describe VCR::Cassette do
           i3.response.body.should =~ /Another example\.com response/
         end
 
+        [true, false].each do |value|
+          it "instantiates the http_interactions with allow_playback_repeats = #{value} if given :allow_playback_repeats => #{value}" do
+            VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
+            cassette = VCR::Cassette.new('example', :record => record_mode, :allow_playback_repeats => value)
+            cassette.http_interactions.allow_playback_repeats.should eq(value)
+          end
+        end
+
+        it "instantiates the http_interactions with parent_list set to a null list if given :exclusive => true" do
+          VCR.stub(:http_interactions => stub)
+          VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
+          cassette = VCR::Cassette.new('example', :record => record_mode, :exclusive => true)
+          cassette.http_interactions.parent_list.should be_a(VCR::Cassette::HTTPInteractionList::NullList)
+        end
+
+        it "instantiates the http_interactions with parent_list set to VCR.http_interactions if given :exclusive => false" do
+          VCR.stub(:http_interactions => stub)
+          VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
+          cassette = VCR::Cassette.new('example', :record => record_mode, :exclusive => false)
+          cassette.http_interactions.parent_list.should be(VCR.http_interactions)
+        end
+
         if stub_requests
           it 'invokes the appropriately tagged before_playback hooks' do
-            VCR::Config.should_receive(:invoke_hook).with(
+            VCR.configuration.should_receive(:invoke_hook).with(
               :before_playback,
               :foo,
               an_instance_of(VCR::HTTPInteraction),
@@ -271,31 +289,27 @@ describe VCR::Cassette do
           end
 
           it 'does not playback any interactions that are ignored in a before_playback hook' do
-            VCR.config do |c|
+            VCR.configure 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"
+            VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/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 = "#{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)
-            VCR::Cassette.new('example', :record => record_mode)
-          end
-
-          it "passes the :match_request_on option to #stub_requests" do
-            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])
-            VCR::Cassette.new('example', :record => record_mode, :match_requests_on => [:body, :headers])
+          it 'instantiates the http_interactions with the loaded interactions and the request matchers' do
+            VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
+            cassette = VCR::Cassette.new('example', :record => record_mode, :match_requests_on => [:body, :headers])
+            cassette.http_interactions.interactions.should have(3).interactions
+            cassette.http_interactions.request_matchers.should == [:body, :headers]
           end
         else
-          it "does not stub the recorded requests with the http stubbing adapter" do
-            VCR::Config.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec"
-            VCR.http_stubbing_adapter.should_not_receive(:stub_requests)
-            VCR::Cassette.new('example', :record => record_mode)
+          it 'instantiates the http_interactions with the no interactions and the request matchers' do
+            VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
+            cassette = VCR::Cassette.new('example', :record => record_mode, :match_requests_on => [:body, :headers])
+            cassette.http_interactions.interactions.should have(0).interactions
+            cassette.http_interactions.request_matchers.should == [:body, :headers]
           end
         end
       end
@@ -303,15 +317,6 @@ describe VCR::Cassette do
   end
 
   describe '#eject' do
-    [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
-        VCR.http_stubbing_adapter.should_receive(:http_connections_allowed?).and_return(orig_http_connections_allowed)
-        cassette = VCR::Cassette.new(:name)
-        VCR.http_stubbing_adapter.should_receive(:http_connections_allowed=).with(orig_http_connections_allowed)
-        cassette.eject
-      end
-    end
-
     it "writes the recorded interactions to disk as yaml" do
       recorded_interactions = [
         VCR::HTTPInteraction.new(:req_sig_1, :response_1),
@@ -337,7 +342,7 @@ describe VCR::Cassette do
       cassette.stub!(:new_recorded_interactions).and_return(interactions)
 
       interactions.each do |i|
-        VCR::Config.should_receive(:invoke_hook).with(
+        VCR.configuration.should_receive(:invoke_hook).with(
           :before_record,
           :foo,
           i,
@@ -388,13 +393,8 @@ describe VCR::Cassette do
         subject { VCR::Cassette.new('example', :record => record_mode, :match_requests_on => [:uri]) }
 
         before(:each) do
-          base_dir = "#{VCR::SPEC_ROOT}/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec"
-          FileUtils.cp(base_dir + "/example.yml", VCR::Config.cassette_library_dir + "/example.yml")
-        end
-
-        it "restore the stubs checkpoint on the http stubbing adapter" do
-          VCR.http_stubbing_adapter.should_receive(:restore_stubs_checkpoint).with(subject)
-          subject.eject
+          base_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
+          FileUtils.cp(base_dir + "/example.yml", VCR.configuration.cassette_library_dir + "/example.yml")
         end
 
         it "does not re-write to disk the previously recorded interactions if there are no new ones" do
@@ -404,74 +404,39 @@ describe VCR::Cassette do
         end
 
         context 'when some new interactions have been recorded' do
-          let(:new_interaction_1) { VCR::HTTPInteraction.new(VCR::Request.new, :response_1) }
-          let(:new_interaction_2) { VCR::HTTPInteraction.new(VCR::Request.new, :response_2) }
-          let(:new_interaction_3) { VCR::HTTPInteraction.new(VCR::Request.new, :response_3) }
-
-          let(:old_interaction_1) { subject.recorded_interactions[0] }
-          let(:old_interaction_2) { subject.recorded_interactions[1] }
-          let(:old_interaction_3) { subject.recorded_interactions[2] }
-
-          let(:saved_recorded_interactions) { VCR::YAML.load_file(subject.file) }
-
-          def stub_matcher_for(interaction, matcher)
-            # There are issues with serializing an object stubbed w/ rspec-mocks using Psych.
-            # So we manually define the method here.
-            class << interaction.request; self; end.class_eval do
-              define_method(:matcher) { |*a| matcher }
+          def interaction(response, request_attributes)
+            request = VCR::Request.new
+            request_attributes.each do |key, value|
+              request.send("#{key}=", value)
             end
+            VCR::HTTPInteraction.new(request, response)
           end
 
-          before(:each) do
-            stub_matcher_for(old_interaction_1, :matcher_c)
-            stub_matcher_for(old_interaction_2, :matcher_d)
-            stub_matcher_for(old_interaction_3, :matcher_c)
+          let(:interaction_foo_1) { interaction("foo 1", :uri => 'http://foo.com/') }
+          let(:interaction_foo_2) { interaction("foo 2", :uri => 'http://foo.com/') }
+          let(:interaction_bar)   { interaction("bar", :uri => 'http://bar.com/') }
 
-            stub_matcher_for(new_interaction_1, :matcher_a)
-            stub_matcher_for(new_interaction_2, :matcher_b)
-            stub_matcher_for(new_interaction_3, :matcher_c)
+          let(:saved_recorded_interactions) { VCR::YAML.load_file(subject.file) }
 
-            [new_interaction_1, new_interaction_2, new_interaction_3].each do |i|
-              subject.record_http_interaction(i)
-            end
+          before(:each) do
+            subject.stub(:recorded_interactions => [interaction_foo_1])
+            subject.record_http_interaction(interaction_foo_2)
+            subject.record_http_interaction(interaction_bar)
+            subject.eject
           end
 
           if record_mode == :all
-            it 'removes the old interactions that match new requests, and saves the new interactions follow the old ones' do
-              subject.eject
-
-              saved_recorded_interactions.should eq([
-                old_interaction_2,
-                new_interaction_1,
-                new_interaction_2,
-                new_interaction_3
-              ])
+            it 'replaces previously recorded interactions with new ones when the requests match' do
+              saved_recorded_interactions.first.should eq(interaction_foo_2)
+              saved_recorded_interactions.should_not include(interaction_foo_1)
             end
 
-            it "matches old requests to new ones using the cassette's match attributes" do
-              pending("Need to fix this to work with Psych", :if => defined?(::Psych)) do
-                [
-                  old_interaction_1, old_interaction_2, old_interaction_3,
-                  new_interaction_1, new_interaction_2, new_interaction_3
-                ].each do |i|
-                  i.request.should_receive(:matcher).with(subject.match_requests_on).and_return(:the_matcher)
-                end
-
-                subject.eject
-              end
-            end unless ENV['CI']
+            it 'appends new recorded interactions that do not match existing ones' do
+              saved_recorded_interactions.last.should eq(interaction_bar)
+            end
           else
-            it 'saves the old interactions followed by the new ones to disk' do
-              subject.eject
-
-              saved_recorded_interactions.should eq([
-                old_interaction_1,
-                old_interaction_2,
-                old_interaction_3,
-                new_interaction_1,
-                new_interaction_2,
-                new_interaction_3
-              ])
+            it 'appends new recorded interactions after existing ones' do
+              saved_recorded_interactions.should eq([interaction_foo_1, interaction_foo_2, interaction_bar])
             end
           end
         end