vcr 1.1.0 → 1.1.1

data/lib/vcr/http_stubbing_adapters/common.rb

@@ -0,0 +1,39 @@
+module VCR
+  module HttpStubbingAdapters
+    autoload :FakeWeb, 'vcr/http_stubbing_adapters/fakeweb'
+    autoload :WebMock, 'vcr/http_stubbing_adapters/webmock'
+
+    class UnsupportedRequestMatchAttributeError < ArgumentError; end
+
+    module Common
+      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 #{self::VERSION_REQUIREMENT} or greater."
+        elsif version_too_high
+          warn "You are using #{library_name} #{version}.  VCR is known to work with #{library_name} ~> #{self::VERSION_REQUIREMENT}.  It may not work with this version."
+        end
+      end
+
+      private
+
+      def compare_version
+        major,     minor,     patch     = *version.split('.').map { |v| v.to_i }
+        req_major, req_minor, req_patch = *self::VERSION_REQUIREMENT.split('.').map { |v| v.to_i }
+
+        return true, false if major < req_major
+        return false, true if major > req_major
+
+        return true, false if minor < req_minor
+        return false, true if minor > req_minor
+
+        return patch < req_patch, false
+      end
+
+      def library_name
+        @library_name ||= self.to_s.split('::').last
+      end
+    end
+  end
+end

data/lib/vcr/http_stubbing_adapters/fakeweb.rb

@@ -3,94 +3,98 @@ require 'vcr/extensions/net_http'
 
 module VCR
   module HttpStubbingAdapters
-    class FakeWeb < Base
-      class << self
-        UNSUPPORTED_REQUEST_MATCH_ATTRIBUTES = [:body, :headers].freeze
-
-        def check_version!
-          unless meets_version_requirement?(::FakeWeb::VERSION, '1.2.8')
-            raise "You are using FakeWeb #{::FakeWeb::VERSION}.  VCR requires version 1.2.8 or greater."
-          end
-        end
+    module FakeWeb
+      include VCR::HttpStubbingAdapters::Common
+      extend self
 
-        def http_connections_allowed?
-          ::FakeWeb.allow_net_connect?
-        end
+      UNSUPPORTED_REQUEST_MATCH_ATTRIBUTES = [:body, :headers].freeze
+      LOCALHOST_REGEX = %r|\Ahttps?://((\w+:)?\w+@)?(#{VCR::LOCALHOST_ALIASES.map { |a| Regexp.escape(a) }.join('|')})(:\d+)?/|i
 
-        def http_connections_allowed=(value)
-          ::FakeWeb.allow_net_connect = value
-        end
+      VERSION_REQUIREMENT = '1.3.0'
 
-        def stub_requests(http_interactions, match_attributes = RequestMatcher::DEFAULT_MATCH_ATTRIBUTES)
-          validate_match_attributes(match_attributes)
-          requests = Hash.new([])
-
-          http_interactions.each do |i|
-            requests[i.request.matcher(match_attributes)] += [i.response]
-          end
-
-          requests.each do |request_matcher, responses|
-            ::FakeWeb.register_uri(
-              request_matcher.method || :any,
-              request_matcher.uri,
-              responses.map{ |r| response_hash(r) }
-            )
-          end
-        end
+      def http_connections_allowed?
+        !!::FakeWeb.allow_net_connect?("http://some.url/besides/localhost")
+      end
 
-        def create_stubs_checkpoint(checkpoint_name)
-          checkpoints[checkpoint_name] = ::FakeWeb::Registry.instance.uri_map.dup
-        end
+      def http_connections_allowed=(value)
+        @http_connections_allowed = value
+        update_fakeweb_allow_net_connect
+      end
 
-        def restore_stubs_checkpoint(checkpoint_name)
-          ::FakeWeb::Registry.instance.uri_map = checkpoints.delete(checkpoint_name)
+      def stub_requests(http_interactions, match_attributes)
+        validate_match_attributes(match_attributes)
+        requests = Hash.new { |h,k| h[k] = [] }
+
+        http_interactions.each do |i|
+          requests[i.request.matcher(match_attributes)] << i.response
         end
 
-        def request_stubbed?(request, match_attributes)
-          validate_match_attributes(match_attributes)
-          ::FakeWeb.registered_uri?(request.method, request.uri)
+        requests.each do |request_matcher, responses|
+          ::FakeWeb.register_uri(
+            request_matcher.method || :any,
+            request_matcher.uri,
+            responses.map{ |r| response_hash(r) }
+          )
         end
+      end
 
-        def request_uri(net_http, request)
-          # Copied from: http://github.com/chrisk/fakeweb/blob/fakeweb-1.2.8/lib/fake_web/ext/net_http.rb#L39-52
-          protocol = net_http.use_ssl? ? "https" : "http"
+      def create_stubs_checkpoint(checkpoint_name)
+        checkpoints[checkpoint_name] = ::FakeWeb::Registry.instance.uri_map.dup
+      end
 
-          path = request.path
-          path = URI.parse(request.path).request_uri if request.path =~ /^http/
+      def restore_stubs_checkpoint(checkpoint_name)
+        ::FakeWeb::Registry.instance.uri_map = checkpoints.delete(checkpoint_name)
+      end
 
-          if request["authorization"] =~ /^Basic /
-            userinfo = ::FakeWeb::Utility.decode_userinfo_from_header(request["authorization"])
-            userinfo = ::FakeWeb::Utility.encode_unsafe_chars_in_userinfo(userinfo) + "@"
-          else
-            userinfo = ""
-          end
+      def request_stubbed?(request, match_attributes)
+        validate_match_attributes(match_attributes)
+        ::FakeWeb.registered_uri?(request.method, request.uri)
+      end
 
-          "#{protocol}://#{userinfo}#{net_http.address}:#{net_http.port}#{path}"
-        end
+      def request_uri(net_http, request)
+        ::FakeWeb::Utility.request_uri_as_string(net_http, request)
+      end
 
-        attr_writer :ignore_localhost
-        def ignore_localhost?
-          @ignore_localhost
-        end
+      def ignore_localhost=(value)
+        @ignore_localhost = value
+        update_fakeweb_allow_net_connect
+      end
 
-        private
+      def ignore_localhost?
+        @ignore_localhost
+      end
 
-        def checkpoints
-          @checkpoints ||= {}
-        end
+      private
 
-        def response_hash(response)
-          response.headers.merge(
-            :body   => response.body,
-            :status => [response.status.code.to_s, response.status.message]
-          )
+      def version
+        ::FakeWeb::VERSION
+      end
+
+      def update_fakeweb_allow_net_connect
+        ::FakeWeb.allow_net_connect = if @http_connections_allowed
+          true
+        elsif @ignore_localhost
+          LOCALHOST_REGEX
+        else
+          false
         end
+      end
+
+      def checkpoints
+        @checkpoints ||= {}
+      end
+
+      def response_hash(response)
+        response.headers.merge(
+          :body   => response.body,
+          :status => [response.status.code.to_s, response.status.message]
+        )
+      end
 
-        def validate_match_attributes(match_attributes)
-          invalid_attributes = match_attributes & UNSUPPORTED_REQUEST_MATCH_ATTRIBUTES
-          if invalid_attributes.size > 0
-            raise UnsupportedRequestMatchAttributeError.new("FakeWeb does not support matching requests on #{invalid_attributes.join(' or ')}")
-          end
+      def validate_match_attributes(match_attributes)
+        invalid_attributes = match_attributes & UNSUPPORTED_REQUEST_MATCH_ATTRIBUTES
+        if invalid_attributes.size > 0
+          raise UnsupportedRequestMatchAttributeError.new("FakeWeb does not support matching requests on #{invalid_attributes.join(' or ')}")
         end
       end
     end

data/lib/vcr/http_stubbing_adapters/webmock.rb

@@ -3,86 +3,85 @@ require 'vcr/extensions/net_http'
 
 module VCR
   module HttpStubbingAdapters
-    class WebMock < Base
-      class << self
-        VERSION_REQUIREMENT = '1.3.3'
-
-        def check_version!
-          unless meets_version_requirement?(::WebMock.version, VERSION_REQUIREMENT)
-            raise "You are using WebMock #{::WebMock.version}.  VCR requires version #{VERSION_REQUIREMENT} or greater."
-          end
-        end
+    module WebMock
+      include VCR::HttpStubbingAdapters::Common
+      extend self
 
-        def http_connections_allowed?
-          ::WebMock::Config.instance.allow_net_connect
-        end
+      VERSION_REQUIREMENT = '1.3.3'
 
-        def http_connections_allowed=(value)
-          ::WebMock::Config.instance.allow_net_connect = value
-        end
+      def http_connections_allowed?
+        ::WebMock::Config.instance.allow_net_connect
+      end
 
-        def stub_requests(http_interactions, match_attributes = RequestMatcher::DEFAULT_MATCH_ATTRIBUTES)
-          requests = Hash.new([])
+      def http_connections_allowed=(value)
+        ::WebMock::Config.instance.allow_net_connect = value
+      end
 
-          http_interactions.each do |i|
-            requests[i.request.matcher(match_attributes)] += [i.response]
-          end
+      def stub_requests(http_interactions, match_attributes)
+        requests = Hash.new { |h,k| h[k] = [] }
 
-          requests.each do |request_matcher, responses|
-            stub = ::WebMock.stub_request(request_matcher.method || :any, request_matcher.uri)
+        http_interactions.each do |i|
+          requests[i.request.matcher(match_attributes)] << i.response
+        end
 
-            with_hash = request_signature_hash(request_matcher)
-            stub = stub.with(with_hash) if with_hash.size > 0
+        requests.each do |request_matcher, responses|
+          stub = ::WebMock.stub_request(request_matcher.method || :any, request_matcher.uri)
 
-            stub.to_return(responses.map{ |r| response_hash(r) })
-          end
-        end
+          with_hash = request_signature_hash(request_matcher)
+          stub = stub.with(with_hash) if with_hash.size > 0
 
-        def create_stubs_checkpoint(checkpoint_name)
-          checkpoints[checkpoint_name] = ::WebMock::RequestRegistry.instance.request_stubs.dup
+          stub.to_return(responses.map{ |r| response_hash(r) })
         end
+      end
 
-        def restore_stubs_checkpoint(checkpoint_name)
-          ::WebMock::RequestRegistry.instance.request_stubs = checkpoints.delete(checkpoint_name)
-        end
+      def create_stubs_checkpoint(checkpoint_name)
+        checkpoints[checkpoint_name] = ::WebMock::RequestRegistry.instance.request_stubs.dup
+      end
 
-        def request_stubbed?(request, match_attributes)
-          matcher = request.matcher(match_attributes)
-          !!::WebMock.registered_request?(::WebMock::RequestSignature.new(matcher.method || :any, request.uri, request_signature_hash(matcher)))
-        end
+      def restore_stubs_checkpoint(checkpoint_name)
+        ::WebMock::RequestRegistry.instance.request_stubs = checkpoints.delete(checkpoint_name)
+      end
 
-        def request_uri(net_http, request)
-          ::WebMock::NetHTTPUtility.request_signature_from_request(net_http, request).uri.to_s
-        end
+      def request_stubbed?(request, match_attributes)
+        matcher = request.matcher(match_attributes)
+        !!::WebMock.registered_request?(::WebMock::RequestSignature.new(matcher.method || :any, request.uri, request_signature_hash(matcher)))
+      end
 
-        def ignore_localhost=(value)
-          ::WebMock::Config.instance.allow_localhost = value
-        end
+      def request_uri(net_http, request)
+        ::WebMock::NetHTTPUtility.request_signature_from_request(net_http, request).uri.to_s
+      end
 
-        def ignore_localhost?
-          ::WebMock::Config.instance.allow_localhost
-        end
+      def ignore_localhost=(value)
+        ::WebMock::Config.instance.allow_localhost = value
+      end
 
-        private
+      def ignore_localhost?
+        ::WebMock::Config.instance.allow_localhost
+      end
 
-        def request_signature_hash(request_matcher)
-          signature = {}
-          signature[:body]    = request_matcher.body    if request_matcher.match_requests_on?(:body)
-          signature[:headers] = request_matcher.headers if request_matcher.match_requests_on?(:headers)
-          signature
-        end
+      private
 
-        def response_hash(response)
-          {
-            :body    => response.body,
-            :status  => [response.status.code.to_i, response.status.message],
-            :headers => response.headers
-          }
-        end
+      def version
+        ::WebMock.version
+      end
 
-        def checkpoints
-          @checkpoints ||= {}
-        end
+      def request_signature_hash(request_matcher)
+        signature = {}
+        signature[:body]    = request_matcher.body    if request_matcher.match_requests_on?(:body)
+        signature[:headers] = request_matcher.headers if request_matcher.match_requests_on?(:headers)
+        signature
+      end
+
+      def response_hash(response)
+        {
+          :body    => response.body,
+          :status  => [response.status.code.to_i, response.status.message],
+          :headers => response.headers
+        }
+      end
+
+      def checkpoints
+        @checkpoints ||= {}
       end
     end
   end

data/lib/vcr/version.rb

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

data/spec/cassette_spec.rb

@@ -0,0 +1,280 @@
+require File.expand_path(File.dirname(__FILE__) + '/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
+
+    it 'combines the cassette_library_dir with the cassette name' do
+      cassette = VCR::Cassette.new('the_file')
+      cassette.file.should == File.join(VCR::Config.cassette_library_dir, 'the_file.yml')
+    end
+
+    it 'strips out disallowed characters so that it is a valid file name with no spaces' do
+      cassette = VCR::Cassette.new("\nthis \t!  is-the_13212_file name")
+      cassette.file.should =~ /#{Regexp.escape('_this_is-the_13212_file_name.yml')}$/
+    end
+
+    it 'keeps any path separators' do
+      cassette = VCR::Cassette.new("dir/file_name")
+      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
+    end
+  end
+
+  describe '#record_http_interaction' do
+    it 'adds the interaction to #recorded_interactions' do
+      cassette = VCR::Cassette.new(:test_cassette)
+      cassette.recorded_interactions.should == []
+      cassette.record_http_interaction(:the_interaction)
+      cassette.recorded_interactions.should == [:the_interaction]
+    end
+  end
+
+  describe '#match_requests_on' do
+    before(:each) { VCR::Config.default_cassette_options.merge!(:match_requests_on => [:uri, :method]) }
+
+    it "returns the provided options" do
+      c = VCR::Cassette.new('example', :match_requests_on => [:uri])
+      c.match_requests_on.should == [:uri]
+    end
+
+    it "returns a the default #match_requests_on when it has not been specified for the cassette" do
+      c = VCR::Cassette.new('example')
+      c.match_requests_on.should == [:uri, :method]
+    end
+  end
+
+  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}")
+      lambda { VCR::Cassette.new('0_3_1_cassette') }.should 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
+      lambda { VCR::Cassette.new(:test, :record => :not_a_record_mode) }.should raise_error(ArgumentError)
+    end
+
+    it 'raises an error if given invalid options' do
+      expect {
+        VCR::Cassette.new(:test, :invalid => :option)
+      }.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')
+    end
+
+    describe 'ERB support' do
+      before(:each) do
+        @orig_default_options = VCR::Config.default_cassette_options
+      end
+
+      after(:each) do
+        VCR::Config.default_cassette_options = @orig_default_options
+      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
+
+      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'
+      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 "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 %>'
+      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
+
+      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
+
+      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
+
+      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"}.}
+        )
+      end
+    end
+
+    VCR::Cassette::VALID_RECORD_MODES.each do |record_mode|
+      http_connections_allowed = (record_mode != :none)
+      load_interactions = (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 } }
+
+        it "defaults the record mode to #{record_mode} when VCR::Config.default_cassette_options[:record] is #{record_mode}" do
+          cassette = VCR::Cassette.new(:test)
+          cassette.record_mode.should == record_mode
+        end
+      end
+
+      context "when the record mode is :#{record_mode}" do
+        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
+
+        if load_interactions
+
+          [true, false].each do |ignore_localhost|
+            expected_uri_hosts = %w(example.com)
+            expected_uri_hosts += VCR::LOCALHOST_ALIASES unless ignore_localhost
+
+            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")
+              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")
+            cassette = VCR::Cassette.new('example', :record => record_mode)
+
+            cassette.should have(3).recorded_interactions
+
+            i1, i2, i3 = *cassette.recorded_interactions
+
+            i1.request.method.should == :get
+            i1.request.uri.should == 'http://example.com:80/'
+            i1.response.body.should =~ /You have reached this web page by typing.+example\.com/
+
+            i2.request.method.should == :get
+            i2.request.uri.should == 'http://example.com:80/foo'
+            i2.response.body.should =~ /foo was not found on this server/
+
+            i3.request.method.should == :get
+            i3.request.uri.should == 'http://example.com:80/'
+            i3.response.body.should =~ /Another example\.com response/
+          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.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.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.http_stubbing_adapter.should_not_receive(:stub_requests)
+            cassette = VCR::Cassette.new('example', :record => record_mode)
+          end
+
+          it "does not load 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")
+            cassette = VCR::Cassette.new('example', :record => record_mode)
+            cassette.should have(0).recorded_interactions
+          end
+
+        end
+      end
+    end
+  end
+
+  describe '#eject' do
+    temp_dir File.expand_path(File.dirname(__FILE__) + '/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
+        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),
+        VCR::HTTPInteraction.new(:req_sig_2, :response_2),
+        VCR::HTTPInteraction.new(:req_sig_3, :response_3)
+      ]
+
+      cassette = VCR::Cassette.new(:eject_test)
+      cassette.stub!(:recorded_interactions).and_return(recorded_interactions)
+
+      lambda { cassette.eject }.should change { File.exist?(cassette.file) }.from(false).to(true)
+      saved_recorded_interactions = File.open(cassette.file, "r") { |f| YAML.load(f.read) }
+      saved_recorded_interactions.should == recorded_interactions
+    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')
+      cassette.stub!(:recorded_interactions).and_return(recorded_interactions)
+
+      lambda { cassette.eject }.should change { File.exist?(cassette.file) }.from(false).to(true)
+      saved_recorded_interactions = File.open(cassette.file, "r") { |f| YAML.load(f.read) }
+      saved_recorded_interactions.should == recorded_interactions
+    end
+
+    it "writes both old and new recorded interactions to disk" do
+      file = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec/example.yml")
+      FileUtils.cp file, File.join(@temp_dir, 'previously_recorded_interactions.yml')
+      cassette = VCR::Cassette.new('previously_recorded_interactions')
+      cassette.should have(3).recorded_interactions
+      new_recorded_interaction = VCR::HTTPInteraction.new(:the_request, :the_response)
+      cassette.record_http_interaction(new_recorded_interaction)
+      cassette.eject
+      saved_recorded_interactions = File.open(cassette.file, "r") { |f| YAML.load(f.read) }
+      saved_recorded_interactions.should have(4).recorded_interactions
+      saved_recorded_interactions.last.should == new_recorded_interaction
+    end
+  end
+
+  describe '#eject for a cassette with previously recorded interactions' do
+    it "restore the stubs checkpoint on the http stubbing adapter" do
+      VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec")
+      cassette = VCR::Cassette.new('example', :record => :none)
+      VCR.http_stubbing_adapter.should_receive(:restore_stubs_checkpoint).with('example')
+      cassette.eject
+    end
+
+    it "does not re-write to disk the previously recorded interactions if there are no new ones" do
+      VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{YAML_SERIALIZATION_VERSION}/cassette_spec")
+      yaml_file = File.join(VCR::Config.cassette_library_dir, 'example.yml')
+      cassette = VCR::Cassette.new('example', :record => :none)
+      File.should_not_receive(:open).with(cassette.file, 'w')
+      lambda { cassette.eject }.should_not change { File.mtime(yaml_file) }
+    end
+  end
+end