vcr 2.5.0 → 2.6.0

data/spec/support/http_library_adapters.rb

@@ -223,7 +223,7 @@ HTTP_LIBRARY_ADAPTERS['excon'] = Module.new do
   end
 
   def normalize_request_headers(headers)
-    headers
+    headers.merge('User-Agent' => [Excon::USER_AGENT])
   end
 end
 

data/spec/support/limited_uri.rb

@@ -1,4 +1,5 @@
 require 'forwardable'
+require 'uri'
 
 class LimitedURI
   extend Forwardable

data/spec/support/shared_example_groups/excon.rb

@@ -1,7 +1,7 @@
 shared_examples "Excon streaming" do
   context "when Excon's streaming API is used" do
     it 'properly records and plays back the response' do
-      VCR.stub(:real_http_connections_allowed? => true)
+      allow(VCR).to receive(:real_http_connections_allowed?).and_return(true)
       recorded, played_back = [1, 2].map do
         chunks = []
 
@@ -17,6 +17,28 @@ shared_examples "Excon streaming" do
       expect(recorded).to eq(played_back)
       expect(recorded).to eq("FOO!")
     end
+
+    it 'properly records and plays back the response for unexpected status' do
+      allow(VCR).to receive(:real_http_connections_allowed?).and_return(true)
+      recorded, played_back = [1, 2].map do
+        chunks = []
+
+        VCR.use_cassette('excon_streaming_error', :record => :once) do
+          begin
+            Excon.get "http://localhost:#{VCR::SinatraApp.port}/404_not_200", :expects => 200, :response_block => lambda { |chunk, remaining_bytes, total_bytes|
+              chunks << chunk
+            }
+          rescue Excon::Errors::Error => e
+            chunks << e.response.body
+          end
+        end
+
+        chunks.join
+      end
+
+      expect(recorded).to eq(played_back)
+      expect(recorded).to eq('404 not 200')
+    end
   end
 end
 

data/spec/support/shared_example_groups/hook_into_http_library.rb

@@ -109,7 +109,7 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
       call_count = 0
       [:has_interaction_matching?, :response_for].each do |method_name|
         orig_meth = VCR.http_interactions.method(method_name)
-        VCR.http_interactions.stub(method_name) do |*args|
+        allow(VCR.http_interactions).to receive(method_name) do |*args|
           call_count += 1
           orig_meth.call(*args)
         end
@@ -135,7 +135,7 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
           VCR.insert_cassette('example')
           disable_real_connections
 
-          VCR.should_receive(:record_http_interaction) do |interaction|
+          expect(VCR).to receive(:record_http_interaction) do |interaction|
             expect(interaction.request.uri).to eq(request_url)
           end
 
@@ -173,7 +173,7 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
 
         it 'does not record requests that are directly stubbed' do
           expect(VCR).to respond_to(:record_http_interaction)
-          VCR.should_not_receive(:record_http_interaction)
+          expect(VCR).not_to receive(:record_http_interaction)
 
           VCR.use_cassette("temp") do
             directly_stub_request(:get, request_url, "stubbed response")
@@ -220,7 +220,7 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
             VCR.use_cassette('new_cassette', &request)
           end
 
-          VCR.should_receive(:record_http_interaction) do
+          expect(VCR).to receive(:record_http_interaction) do
             expect(VCR.current_cassette.name).to eq('new_cassette')
           end
 
@@ -370,7 +370,7 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
           specify 'the after_http_request hook can be used to eject a cassette after the request is recorded' do
             VCR.configuration.after_http_request { |request| VCR.eject_cassette }
 
-            VCR.should_receive(:record_http_interaction) do |interaction|
+            expect(VCR).to receive(:record_http_interaction) do |interaction|
               expect(VCR.current_cassette).to be(inserted_cassette)
             end
 
@@ -408,7 +408,7 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
     end
 
     describe '.stub_requests using specific match_attributes' do
-      before(:each) { VCR.stub(:real_http_connections_allowed? => false) }
+      before(:each) { allow(VCR).to receive(:real_http_connections_allowed?).and_return(false) }
       let(:interactions) { interactions_from('match_requests_on.yml') }
 
       let(:normalized_interactions) do
@@ -486,17 +486,17 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
         describe 'recording new http requests' do
           let(:recorded_interaction) do
             interaction = nil
-            VCR.should_receive(:record_http_interaction) { |i| interaction = i }
+            expect(VCR).to receive(:record_http_interaction) { |i| interaction = i }
             make_http_request(:post, url, "the body", { 'X-Http-Foo' => 'bar' })
             interaction
           end
 
           it 'does not record the request if the hook is disabled' do
             VCR.library_hooks.exclusively_enabled :something_else do
-              VCR.should_not_receive(:record_http_interaction)
+              expect(VCR).not_to receive(:record_http_interaction)
               make_http_request(:get, url)
             end
-          end unless other.include?(:not_disableable)
+          end
 
           it 'records the request uri' do
             expect(recorded_interaction.request.uri).to eq(url)
@@ -534,7 +534,7 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
         end
       else
         it 'does not allow real HTTP requests or record them' do
-          VCR.should_receive(:record_http_interaction).never
+          expect(VCR).to receive(:record_http_interaction).never
           expect { make_http_request(:get, url) }.to raise_error(NET_CONNECT_NOT_ALLOWED_ERROR)
         end
       end
@@ -542,7 +542,7 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
 
     [true, false].each do |http_allowed|
       context "when VCR.real_http_connections_allowed? is returning #{http_allowed}" do
-        before(:each) { VCR.stub(:real_http_connections_allowed? => http_allowed) }
+        before(:each) { allow(VCR).to receive(:real_http_connections_allowed?).and_return(http_allowed) }
 
         test_real_http_request(http_allowed, *other)
 
@@ -573,7 +573,7 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
           end
 
           it 'gets the stubbed responses when requests are made to http://example.com/foo, and does not record them' do
-            VCR.should_receive(:record_http_interaction).never
+            expect(VCR).to receive(:record_http_interaction).never
             expect(get_body_string(make_http_request(:get, 'http://example.com/foo'))).to match(/example\.com get response \d with path=foo/)
           end
 

data/spec/support/shared_example_groups/request_hooks.rb

@@ -30,7 +30,7 @@ shared_examples_for "request hooks" do |library_hook_name, request_type|
 
     specify "the #{hook} hook is not called if the library hook is disabled" do
       expect(VCR.library_hooks).to respond_to(:disabled?)
-      VCR.library_hooks.stub(:disabled? => true)
+      allow(VCR.library_hooks).to receive(:disabled?).and_return(true)
 
       hook_called = false
       VCR.configuration.send(hook) { |r| hook_called = true }

data/spec/support/sinatra_app.rb

@@ -20,6 +20,10 @@ module VCR
       "FOO!"
     end
 
+    get '/redirect-to-root' do
+      redirect to('/')
+    end
+
     post '/foo' do
       "FOO!"
     end
@@ -38,6 +42,11 @@ module VCR
       status 204
     end
 
+    get '/404_not_200' do
+      status 404
+      '404 not 200'
+    end
+
     # we use a global counter so that every response is different;
     # this ensures that the test demonstrates that the response
     # is being played back (and not running a 2nd real request)

data/spec/support/vcr_localhost_server.rb

@@ -57,31 +57,10 @@ module VCR
     end
 
     def concurrently
-      if should_use_subprocess?
-        pid = Process.fork do
-          trap(:INT) { ::Rack::Handler::WEBrick.shutdown }
-          yield
-          exit # manually exit; otherwise this sub-process will re-run the specs that haven't run yet.
-        end
-
-        at_exit do
-          Process.kill('INT', pid)
-          begin
-            Process.wait(pid)
-          rescue Errno::ECHILD
-            # ignore this error...I think it means the child process has already exited.
-          end
-        end
-      else
-        # JRuby doesn't support forking.
-        # Rubinius does, but there's a weird issue with the booted? check not working,
-        # so we're just using a thread for now.
-        Thread.new { yield }
-      end
-    end
-
-    def should_use_subprocess?
-      false
+      # JRuby doesn't support forking.
+      # Rubinius does, but there's a weird issue with the booted? check not working,
+      # so we're just using a thread for now.
+      Thread.new { yield }
     end
 
     def wait_until(timeout, error_message, &block)

data/spec/support/vcr_stub_helpers.rb

@@ -5,7 +5,7 @@ module VCRStubHelpers
   end
 
   def stub_requests(*args)
-    VCR.stub(:http_interactions => VCR::Cassette::HTTPInteractionList.new(*args))
+    allow(VCR).to receive(:http_interactions).and_return(VCR::Cassette::HTTPInteractionList.new(*args))
   end
 
   def http_interaction(url, response_body = "FOO!", status_code = 200)

data/spec/vcr/cassette/http_interaction_list_spec.rb

@@ -2,17 +2,20 @@ require 'vcr/util/logger'
 require 'vcr/cassette/http_interaction_list'
 require 'vcr/request_matcher_registry'
 require 'vcr/structs'
+require 'support/configuration_stubbing'
 
 module VCR
   class Cassette
     describe HTTPInteractionList do
+      include_context "configuration stubbing"
+
       ::RSpec::Matchers.define :respond_with do |expected|
         match { |a| expected.nil? ? a.nil? : a.body == expected }
       end
 
       before(:each) do
-        VCR.stub(:request_matchers => VCR::RequestMatcherRegistry.new)
-        VCR.stub_chain(:configuration, :debug_logger).and_return(stub.as_null_object)
+        allow(VCR).to receive(:request_matchers).and_return(VCR::RequestMatcherRegistry.new)
+        allow(config).to receive(:logger).and_return(double.as_null_object)
       end
 
       def request_with(values)
@@ -87,22 +90,46 @@ module VCR
 
       describe "#assert_no_unused_interactions?" do
         it 'should raise a SkippedHTTPRequestError when there are unused interactions left' do
-           expect { list.assert_no_unused_interactions! }.to raise_error(Errors::UnusedHTTPInteractionError)
-           list.response_for(request_with(:method => :put))
-           expect { list.assert_no_unused_interactions! }.to raise_error(Errors::UnusedHTTPInteractionError)
+          expect {
+            list.assert_no_unused_interactions!
+          }.to raise_error(Errors::UnusedHTTPInteractionError)
+
+          list.response_for(request_with(:method => :put))
+          expect {
+            list.assert_no_unused_interactions!
+          }.to raise_error(Errors::UnusedHTTPInteractionError)
         end
 
         it 'should raise nothing when there are no unused interactions left' do
           [:put, :post, :post].each do |method|
             list.response_for(request_with(:method => method))
           end
-          list.assert_no_unused_interactions! # should not raise an error.
+
+          expect {
+            list.assert_no_unused_interactions!
+          }.not_to raise_error
+        end
+
+        context 'when the null logger is in use' do
+          before { allow(config).to receive(:logger).and_return(Logger::Null) }
+
+          it 'includes formatted request details in the error message' do
+            expect {
+              list.assert_no_unused_interactions!
+            }.to raise_error(/\[put/)
+          end
+
+          it 'includes formatted response details in the error message' do
+            expect {
+              list.assert_no_unused_interactions!
+            }.to raise_error(/\[200 "put response"\]/)
+          end
         end
       end
 
       describe "has_interaction_matching?" do
         it 'returns false when the list is empty' do
-          expect(HTTPInteractionList.new([], [:method])).not_to have_interaction_matching(stub)
+          expect(HTTPInteractionList.new([], [:method])).not_to have_interaction_matching(double)
         end
 
         it 'returns false when there is no matching interaction' do
@@ -136,10 +163,10 @@ module VCR
         end
 
         it "delegates to the parent list when it can't find a matching interaction" do
-          parent_list = mock(:has_interaction_matching? => true)
-          expect(HTTPInteractionList.new( [], [:method], false, parent_list)).to have_interaction_matching(stub)
-          parent_list = mock(:has_interaction_matching? => false)
-          expect(HTTPInteractionList.new( [], [:method], false, parent_list)).not_to have_interaction_matching(stub)
+          parent_list = double(:has_interaction_matching? => true)
+          expect(HTTPInteractionList.new( [], [:method], false, parent_list)).to have_interaction_matching(double)
+          parent_list = double(:has_interaction_matching? => false)
+          expect(HTTPInteractionList.new( [], [:method], false, parent_list)).not_to have_interaction_matching(double)
         end
 
         context 'when allow_playback_repeats is set to true' do
@@ -173,7 +200,7 @@ module VCR
 
       describe "#response_for" do
         it 'returns nil when the list is empty' do
-          expect(HTTPInteractionList.new([], [:method]).response_for(stub)).to respond_with(nil)
+          expect(HTTPInteractionList.new([], [:method]).response_for(double)).to respond_with(nil)
         end
 
         it 'returns nil when there is no matching interaction' do
@@ -213,10 +240,10 @@ module VCR
         end
 
         it "delegates to the parent list when it can't find a matching interaction" do
-          parent_list = mock(:response_for => response('parent'))
+          parent_list = double(:response_for => response('parent'))
           result = HTTPInteractionList.new(
             [], [:method], false, parent_list
-          ).response_for(stub)
+          ).response_for(double)
 
           expect(result).to respond_with('parent')
         end

data/spec/vcr/cassette/migrator_spec.rb

@@ -130,7 +130,7 @@ EOF
   subject { described_class.new(dir, out_io) }
 
   before(:each) do
-    File.stub(:mtime).with(file_name).and_return(filemtime)
+    allow(File).to receive(:mtime).with(file_name).and_return(filemtime)
   end
 
   it 'migrates a cassette from the 1.x to 2.x format' do

data/spec/vcr/cassette/persisters_spec.rb

@@ -7,7 +7,7 @@ module VCR
         context 'when there is already a persister registered for the given name' do
           before(:each) do
             subject[:foo] = :old_persister
-            subject.stub :warn
+            allow(subject).to receive :warn
           end
 
           it 'overrides the existing persister' do
@@ -16,7 +16,7 @@ module VCR
           end
 
           it 'warns that there is a name collision' do
-            subject.should_receive(:warn).with(
+            expect(subject).to receive(:warn).with(
               /WARNING: There is already a VCR cassette persister registered for :foo\. Overriding it/
             )
             subject[:foo] = :new_persister

data/spec/vcr/cassette/serializers_spec.rb

@@ -69,11 +69,20 @@ module VCR
       it_behaves_like "a serializer", :json,  "json", :lazily_loaded do
         engines = {}
 
-        engines[:yajl] = ::MultiJson::DecodeError unless RUBY_INTERPRETER == :jruby
+        if RUBY_INTERPRETER == :jruby
+          # don't test yajl on jruby
+        elsif RUBY_VERSION.to_f < 1.9
+          engines[:yajl] = MultiJson::LoadError
+        else
+          engines[:yajl] = ArgumentError
+        end
 
         if RUBY_VERSION =~ /1.9/
           engines[:json_gem] = EncodingError
-          engines[:json_pure] = EncodingError
+
+          # Disable json_pure for now due to this bug:
+          # https://github.com/flori/json/issues/186
+          # engines[:json_pure] = EncodingError
         end
 
         engines.each do |engine, error|
@@ -114,7 +123,7 @@ module VCR
         context 'when there is already a serializer registered for the given name' do
           before(:each) do
             subject[:foo] = :old_serializer
-            subject.stub :warn
+            allow(subject).to receive :warn
           end
 
           it 'overrides the existing serializer' do
@@ -123,7 +132,7 @@ module VCR
           end
 
           it 'warns that there is a name collision' do
-            subject.should_receive(:warn).with(
+            expect(subject).to receive(:warn).with(
               /WARNING: There is already a VCR cassette serializer registered for :foo\. Overriding it/
             )
             subject[:foo] = :new_serializer

data/spec/vcr/cassette_spec.rb

@@ -8,16 +8,26 @@ describe VCR::Cassette do
     VCR::HTTPInteraction.new(request, response).tap { |i| yield i if block_given? }
   end
 
+  def stub_old_interactions(interactions)
+    VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
+
+    hashes = interactions.map(&:to_hash)
+    allow(VCR.cassette_serializers[:yaml]).to receive(:deserialize).and_return({ 'http_interactions' => hashes })
+    allow(VCR::HTTPInteraction).to receive(:from_hash) do |hash|
+      interactions[hashes.index(hash)]
+    end
+  end
+
   describe '#file' do
     it 'delegates the file resolution to the FileSystem persister' do
       fs = VCR::Cassette::Persisters::FileSystem
       expect(fs).to respond_to(:absolute_path_to_file).with(1).argument
-      fs.should_receive(:absolute_path_to_file).with("cassette name.yml") { "f.yml" }
+      expect(fs).to receive(:absolute_path_to_file).with("cassette name.yml") { "f.yml" }
       expect(VCR::Cassette.new("cassette name").file).to eq("f.yml")
     end
 
     it 'raises a NotImplementedError when a different persister is used' do
-      VCR.cassette_persisters[:a] = stub
+      VCR.cassette_persisters[:a] = double
       cassette = VCR::Cassette.new("f", :persist_with => :a)
       expect { cassette.file }.to raise_error(NotImplementedError)
     end
@@ -38,7 +48,7 @@ describe VCR::Cassette do
   end
 
   describe '#record_http_interaction' do
-    let(:the_interaction) { stub(:request => stub(:method => :get).as_null_object).as_null_object }
+    let(:the_interaction) { double(:request => double(:method => :get).as_null_object).as_null_object }
 
     it 'adds the interaction to #new_recorded_interactions' do
       cassette = VCR::Cassette.new(:test_cassette)
@@ -63,8 +73,8 @@ describe VCR::Cassette do
     let(:metadata) { subject.serializable_hash.reject { |k,v| k == "http_interactions" } }
 
     it 'includes the hash form of all recorded interactions' do
-      interaction_1.stub(:to_hash => { "i" => 1, 'body' => '' })
-      interaction_2.stub(:to_hash => { "i" => 2, 'body' => '' })
+      allow(interaction_1).to receive(:to_hash).and_return({ "i" => 1, 'body' => '' })
+      allow(interaction_2).to receive(:to_hash).and_return({ "i" => 2, 'body' => '' })
       expect(subject.serializable_hash).to include('http_interactions' => [{ "i" => 1, 'body' => '' }, { "i" => 2, 'body' => '' }])
     end
 
@@ -131,11 +141,11 @@ describe VCR::Cassette do
     let(:empty_cassette_yaml) { YAML.dump("http_interactions" => []) }
 
     it 'optionally renders the file as ERB using the ERBRenderer' do
-      VCR::Cassette::Persisters::FileSystem.stub(:[] => empty_cassette_yaml)
+      allow(VCR::Cassette::Persisters::FileSystem).to receive(:[]).and_return(empty_cassette_yaml)
 
-      VCR::Cassette::ERBRenderer.should_receive(:new).with(
+      expect(VCR::Cassette::ERBRenderer).to receive(:new).with(
         empty_cassette_yaml, anything, "foo"
-      ).and_return(mock('renderer', :render => empty_cassette_yaml))
+      ).and_return(double('renderer', :render => empty_cassette_yaml))
 
       VCR::Cassette.new('foo', :record => :new_episodes).http_interactions
     end
@@ -145,9 +155,9 @@ describe VCR::Cassette do
         # test that it overrides the default
         VCR.configuration.default_cassette_options = { :erb => true }
 
-        VCR::Cassette::ERBRenderer.should_receive(:new).with(
+        expect(VCR::Cassette::ERBRenderer).to receive(:new).with(
           anything, erb, anything
-        ).and_return(mock('renderer', :render => empty_cassette_yaml))
+        ).and_return(double('renderer', :render => empty_cassette_yaml))
 
         VCR::Cassette.new('foo', :record => :new_episodes, :erb => erb).http_interactions
       end
@@ -155,9 +165,9 @@ describe VCR::Cassette do
       it "passes #{erb.inspect} to the VCR::Cassette::ERBRenderer when it is the default :erb option and none is given" do
         VCR.configuration.default_cassette_options = { :erb => erb }
 
-        VCR::Cassette::ERBRenderer.should_receive(:new).with(
+        expect(VCR::Cassette::ERBRenderer).to receive(:new).with(
           anything, erb, anything
-        ).and_return(mock('renderer', :render => empty_cassette_yaml))
+        ).and_return(double('renderer', :render => empty_cassette_yaml))
 
         VCR::Cassette.new('foo', :record => :new_episodes).http_interactions
       end
@@ -187,12 +197,12 @@ describe VCR::Cassette do
       expect(VCR::Cassette.new('empty', :record => :none).send(:previously_recorded_interactions)).to eq([])
     end
 
-    let(:custom_persister) { stub("custom persister") }
+    let(:custom_persister) { double("custom persister") }
 
     it 'reads from the configured persister' do
       VCR.configuration.cassette_library_dir = nil
       VCR.cassette_persisters[:foo] = custom_persister
-      custom_persister.should_receive(:[]).with("abc.yml") { "" }
+      expect(custom_persister).to receive(:[]).with("abc.yml") { "" }
       VCR::Cassette.new("abc", :persist_with => :foo).http_interactions
     end
 
@@ -209,24 +219,15 @@ describe VCR::Cassette do
       end
 
       context "when :#{record_mode} is passed as the record option" do
-        def stub_old_interactions(interactions)
-          hashes = interactions.map(&:to_hash)
-          VCR.cassette_serializers[:yaml].stub(:deserialize => { 'http_interactions' => hashes })
-          VCR::HTTPInteraction.stub(:from_hash) do |hash|
-            interactions[hashes.index(hash)]
-          end
-        end
-
         unless record_mode == :all
           let(:interaction_1) { http_interaction { |i| i.request.uri = 'http://example.com/foo' } }
           let(:interaction_2) { http_interaction { |i| i.request.uri = 'http://example.com/bar' } }
           let(:interactions)  { [interaction_1, interaction_2] }
-          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
             stub_old_interactions(interactions)
-            interaction_1.response.should_receive(:update_content_length_header)
-            interaction_2.response.should_receive(:update_content_length_header)
+            expect(interaction_1.response).to receive(:update_content_length_header)
+            expect(interaction_2.response).to receive(:update_content_length_header)
 
             VCR::Cassette.new('example', :record => record_mode, :update_content_length_header => true).http_interactions
           end
@@ -234,8 +235,8 @@ describe VCR::Cassette do
           [nil, false].each do |val|
             it "does not update the content_lenth headers when given :update_content_length_header => #{val.inspect}" do
               stub_old_interactions(interactions)
-              interaction_1.response.should_not_receive(:update_content_length_header)
-              interaction_2.response.should_not_receive(:update_content_length_header)
+              expect(interaction_1.response).not_to receive(:update_content_length_header)
+              expect(interaction_2.response).not_to receive(:update_content_length_header)
 
               VCR::Cassette.new('example', :record => record_mode, :update_content_length_header => val).http_interactions
             end
@@ -246,7 +247,7 @@ describe VCR::Cassette do
             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
-              before(:each) { File.stub(:exist?).with(file_name).and_return(false) }
+              before(:each) { allow(File).to receive(:exist?).with(file_name).and_return(false) }
 
               it "has :#{record_mode} for the record mode" do
                 expect(subject.record_mode).to eq(record_mode)
@@ -260,9 +261,9 @@ describe VCR::Cassette do
                 end
                 yaml = YAML.dump("http_interactions" => interactions)
 
-                File.stub(:exist?).with(file_name).and_return(true)
-                File.stub(:size?).with(file_name).and_return(true)
-                File.stub(:read).with(file_name).and_return(yaml)
+                allow(File).to receive(:exist?).with(file_name).and_return(true)
+                allow(File).to receive(:size?).with(file_name).and_return(true)
+                allow(File).to receive(:read).with(file_name).and_return(yaml)
               end
 
               context 'and the earliest recorded interaction was recorded less than 7 days ago' do
@@ -285,12 +286,12 @@ describe VCR::Cassette do
                 ] end
 
                 it "has :all for the record mode when there is an internet connection available" do
-                  VCR::InternetConnection.stub(:available? => true)
+                  allow(VCR::InternetConnection).to receive(:available?).and_return(true)
                   expect(subject.record_mode).to eq(:all)
                 end
 
                 it "has :#{record_mode} for the record mode when there is no internet connection available" do
-                  VCR::InternetConnection.stub(:available? => false)
+                  allow(VCR::InternetConnection).to receive(:available?).and_return(false)
                   expect(subject.record_mode).to eq(record_mode)
                 end
               end
@@ -299,7 +300,7 @@ describe VCR::Cassette do
         end
 
         it 'does not load ignored interactions' do
-          VCR.request_ignorer.stub(:ignore?) do |request|
+          allow(VCR.request_ignorer).to receive(:ignore?) do |request|
             request.uri !~ /example\.com/
           end
 
@@ -338,14 +339,14 @@ describe VCR::Cassette do
         end
 
         it "instantiates the http_interactions with parent_list set to a null list if given :exclusive => true" do
-          VCR.stub(:http_interactions => stub)
+          allow(VCR).to receive(:http_interactions).and_return(double)
           VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
           cassette = VCR::Cassette.new('example', :record => record_mode, :exclusive => true)
           expect(cassette.http_interactions.parent_list).to be(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)
+          allow(VCR).to receive(:http_interactions).and_return(double)
           VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
           cassette = VCR::Cassette.new('example', :record => record_mode, :exclusive => false)
           expect(cassette.http_interactions.parent_list).to be(VCR.http_interactions)
@@ -353,7 +354,9 @@ describe VCR::Cassette do
 
         if stub_requests
           it 'invokes the before_playback hooks' do
-            VCR.configuration.should_receive(:invoke_hook).with(
+            VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
+
+            expect(VCR.configuration).to receive(:invoke_hook).with(
               :before_playback,
               an_instance_of(VCR::HTTPInteraction::HookAware),
               an_instance_of(VCR::Cassette)
@@ -391,17 +394,63 @@ describe VCR::Cassette do
     end
   end
 
+  describe ".originally_recorded_at" do
+    it 'returns the earliest `recorded_at` timestamp' do
+      i1 = http_interaction { |i| i.recorded_at = Time.now - 1000 }
+      i2 = http_interaction { |i| i.recorded_at = Time.now - 10000 }
+      i3 = http_interaction { |i| i.recorded_at = Time.now - 100 }
+
+      stub_old_interactions([i1, i2, i3])
+
+      cassette = VCR::Cassette.new("example")
+      expect(cassette.originally_recorded_at).to eq(i2.recorded_at)
+    end
+
+    it 'records nil for a cassette that has no prior recorded interactions' do
+      stub_old_interactions([])
+      cassette = VCR::Cassette.new("example")
+      expect(cassette.originally_recorded_at).to be_nil
+    end
+  end
+
   describe '#eject' do
-    let(:custom_persister) { stub("custom persister", :[] => nil) }
+    let(:custom_persister) { double("custom persister", :[] => nil) }
 
-    it 'asserts that there are no unused interactions if allow_unused_http_interactions is set to false' do
-      cassette = VCR.insert_cassette("foo", :allow_unused_http_interactions => false)
+    context "when :allow_unused_http_interactions is set to false" do
+      it 'asserts that there are no unused interactions' do
+        cassette = VCR.insert_cassette("foo", :allow_unused_http_interactions => false)
 
-      interaction_list = cassette.http_interactions
-      expect(interaction_list).to respond_to(:assert_no_unused_interactions!).with(0).arguments
-      interaction_list.should_receive(:assert_no_unused_interactions!)
+        interaction_list = cassette.http_interactions
+        expect(interaction_list).to respond_to(:assert_no_unused_interactions!).with(0).arguments
+        expect(interaction_list).to receive(:assert_no_unused_interactions!)
 
-      cassette.eject
+        cassette.eject
+      end
+
+      it 'does not assert no unused interactions if there is an existing error' do
+        cassette = VCR.insert_cassette("foo", :allow_unused_http_interactions => false)
+        interaction_list = cassette.http_interactions
+        allow(interaction_list).to receive(:assert_no_unused_interactions!)
+
+        expect {
+          begin
+            raise "boom"
+          ensure
+            cassette.eject
+          end
+        }.to raise_error(/boom/)
+
+        expect(interaction_list).not_to have_received(:assert_no_unused_interactions!)
+      end
+
+      it 'does not assert no unused interactions if :skip_no_unused_interactions_assertion is passed' do
+        cassette = VCR.insert_cassette("foo", :allow_unused_http_interactions => false)
+
+        interaction_list = cassette.http_interactions
+        expect(interaction_list).not_to receive(:assert_no_unused_interactions!)
+
+        cassette.eject(:skip_no_unused_interactions_assertion => true)
+      end
     end
 
     it 'does not assert that there are no unused interactions if allow_unused_http_interactions is set to true' do
@@ -409,7 +458,7 @@ describe VCR::Cassette do
 
       interaction_list = cassette.http_interactions
       expect(interaction_list).to respond_to(:assert_no_unused_interactions!)
-      interaction_list.should_not_receive(:assert_no_unused_interactions!)
+      expect(interaction_list).not_to receive(:assert_no_unused_interactions!)
 
       cassette.eject
     end
@@ -420,7 +469,7 @@ describe VCR::Cassette do
       cassette = VCR.insert_cassette("foo", :persist_with => :foo)
       cassette.record_http_interaction http_interaction
 
-      custom_persister.should_receive(:[]=).with("foo.yml", /http_interactions/)
+      expect(custom_persister).to receive(:[]=).with("foo.yml", /http_interactions/)
 
       cassette.eject
     end
@@ -429,7 +478,7 @@ describe VCR::Cassette do
       cassette = VCR::Cassette.new(:eject_test)
       cassette.record_http_interaction http_interaction # so it has one
       expect(cassette).to respond_to(:serializable_hash)
-      cassette.stub(:serializable_hash => { "http_interactions" => [1, 3, 5] })
+      allow(cassette).to receive(:serializable_hash).and_return({ "http_interactions" => [1, 3, 5] })
 
       expect { cassette.eject }.to change { File.exist?(cassette.file) }.from(false).to(true)
       saved_stuff = YAML.load_file(cassette.file)
@@ -443,12 +492,12 @@ describe VCR::Cassette do
       ]
 
       cassette = VCR::Cassette.new('example', :tag => :foo)
-      cassette.stub!(:new_recorded_interactions).and_return(interactions)
+      allow(cassette).to receive(:new_recorded_interactions).and_return(interactions)
 
-      VCR.configuration.stub(:invoke_hook).and_return([false])
+      allow(VCR.configuration).to receive(:invoke_hook).and_return([false])
 
       interactions.each do |i|
-        VCR.configuration.should_receive(:invoke_hook).with(
+        expect(VCR.configuration).to receive(:invoke_hook).with(
           :before_record,
           an_instance_of(VCR::HTTPInteraction::HookAware),
           cassette
@@ -463,11 +512,11 @@ describe VCR::Cassette do
       interaction_2 = http_interaction { |i| i.request.uri = 'http://bar.com/'; i.response.body = 'res 2' }
 
       hook_aware_interaction_1 = interaction_1.hook_aware
-      interaction_1.stub(:hook_aware => hook_aware_interaction_1)
+      allow(interaction_1).to receive(:hook_aware).and_return(hook_aware_interaction_1)
       hook_aware_interaction_1.ignore!
 
       cassette = VCR::Cassette.new('test_cassette')
-      cassette.stub!(:new_recorded_interactions).and_return([interaction_1, interaction_2])
+      allow(cassette).to receive(:new_recorded_interactions).and_return([interaction_1, interaction_2])
       cassette.eject
 
       saved_recorded_interactions = ::YAML.load_file(cassette.file)
@@ -478,11 +527,11 @@ describe VCR::Cassette do
       interaction_1 = http_interaction { |i| i.request.uri = 'http://foo.com/'; i.response.body = 'res 1' }
 
       hook_aware_interaction_1 = interaction_1.hook_aware
-      interaction_1.stub(:hook_aware => hook_aware_interaction_1)
+      allow(interaction_1).to receive(:hook_aware).and_return(hook_aware_interaction_1)
       hook_aware_interaction_1.ignore!
 
       cassette = VCR::Cassette.new('test_cassette')
-      cassette.stub!(:new_recorded_interactions).and_return([interaction_1])
+      allow(cassette).to receive(:new_recorded_interactions).and_return([interaction_1])
       cassette.eject
 
       expect(File).not_to exist(cassette.file)
@@ -491,7 +540,7 @@ describe VCR::Cassette do
     it "writes the recorded interactions to a subdirectory if the cassette name includes a directory" do
       recorded_interactions = [http_interaction { |i| i.response.body = "subdirectory response" }]
       cassette = VCR::Cassette.new('subdirectory/test_cassette')
-      cassette.stub(:new_recorded_interactions => recorded_interactions)
+      allow(cassette).to receive(:new_recorded_interactions).and_return(recorded_interactions)
 
       expect { cassette.eject }.to change { File.exist?(cassette.file) }.from(false).to(true)
       saved_recorded_interactions = YAML.load_file(cassette.file)
@@ -509,7 +558,7 @@ describe VCR::Cassette do
 
         it "does not re-write to disk the previously recorded interactions if there are no new ones" do
           yaml_file = subject.file
-          File.should_not_receive(:open).with(subject.file, 'w')
+          expect(File).not_to receive(:open).with(subject.file, 'w')
           expect { subject.eject }.to_not change { File.mtime(yaml_file) }
         end
 
@@ -531,8 +580,8 @@ describe VCR::Cassette do
           let(:now) { Time.utc(2011, 6, 11, 12, 30) }
 
           before(:each) do
-            Time.stub(:now => now)
-            subject.stub(:previously_recorded_interactions => [interaction_foo_1])
+            allow(Time).to receive(:now).and_return(now)
+            allow(subject).to receive(:previously_recorded_interactions).and_return([interaction_foo_1])
             subject.record_http_interaction(interaction_foo_2)
             subject.record_http_interaction(interaction_bar)
             subject.eject