vcr 2.4.0 → 2.5.0

data/spec/vcr/cassette_spec.rb

@@ -11,9 +11,9 @@ describe VCR::Cassette do
   describe '#file' do
     it 'delegates the file resolution to the FileSystem persister' do
       fs = VCR::Cassette::Persisters::FileSystem
-      fs.should respond_to(:absolute_path_to_file).with(1).argument
+      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" }
-      VCR::Cassette.new("cassette name").file.should eq("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
@@ -25,15 +25,15 @@ describe VCR::Cassette do
 
   describe '#tags' do
     it 'returns a blank array if no tag has been set' do
-      VCR::Cassette.new("name").tags.should eq([])
+      expect(VCR::Cassette.new("name").tags).to eq([])
     end
 
     it 'converts a single :tag to an array' do
-      VCR::Cassette.new("name", :tag => :foo).tags.should eq([:foo])
+      expect(VCR::Cassette.new("name", :tag => :foo).tags).to eq([:foo])
     end
 
     it 'accepts an array as the :tags option' do
-      VCR::Cassette.new("name", :tags => [:foo]).tags.should eq([:foo])
+      expect(VCR::Cassette.new("name", :tags => [:foo]).tags).to eq([:foo])
     end
   end
 
@@ -42,9 +42,9 @@ describe VCR::Cassette do
 
     it 'adds the interaction to #new_recorded_interactions' do
       cassette = VCR::Cassette.new(:test_cassette)
-      cassette.new_recorded_interactions.should eq([])
+      expect(cassette.new_recorded_interactions).to eq([])
       cassette.record_http_interaction(the_interaction)
-      cassette.new_recorded_interactions.should eq([the_interaction])
+      expect(cassette.new_recorded_interactions).to eq([the_interaction])
     end
   end
 
@@ -65,11 +65,11 @@ describe VCR::Cassette do
     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' => '' })
-      subject.serializable_hash.should include('http_interactions' => [{ "i" => 1, 'body' => '' }, { "i" => 2, 'body' => '' }])
+      expect(subject.serializable_hash).to include('http_interactions' => [{ "i" => 1, 'body' => '' }, { "i" => 2, 'body' => '' }])
     end
 
     it 'includes additional metadata about the cassette' do
-      metadata.should eq("recorded_with" => "VCR #{VCR.version}")
+      expect(metadata).to eq("recorded_with" => "VCR #{VCR.version}")
     end
   end
 
@@ -77,13 +77,13 @@ describe VCR::Cassette 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
+        expect(cassette).to 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
+      expect(cassette).not_to be_recording
     end
 
     context 'when the record mode is :once' do
@@ -93,22 +93,22 @@ describe VCR::Cassette do
 
       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
+        expect(File).to exist(cassette.file)
+        expect(File.size?(cassette.file)).to be_true
+        expect(cassette).not_to 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
+        expect(File).to exist(cassette.file)
+        expect(File.size?(cassette.file)).to be_false
+        expect(cassette).to 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
+        expect(File).not_to exist(cassette.file)
+        expect(cassette).to be_recording
       end
     end
   end
@@ -118,12 +118,12 @@ describe VCR::Cassette do
 
     it "returns the provided options" do
       c = VCR::Cassette.new('example', :match_requests_on => [:uri])
-      c.match_requests_on.should eq([:uri])
+      expect(c.match_requests_on).to eq([: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 eq([:uri, :method])
+      expect(c.match_requests_on).to eq([:uri, :method])
     end
   end
 
@@ -184,7 +184,7 @@ describe VCR::Cassette do
 
     it 'does not raise an error in the case of an empty file' do
       VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
-      VCR::Cassette.new('empty', :record => :none).send(:previously_recorded_interactions).should eq([])
+      expect(VCR::Cassette.new('empty', :record => :none).send(:previously_recorded_interactions)).to eq([])
     end
 
     let(:custom_persister) { stub("custom persister") }
@@ -204,7 +204,7 @@ describe VCR::Cassette 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)
+          expect(cassette.record_mode).to eq(record_mode)
         end
       end
 
@@ -249,7 +249,7 @@ describe VCR::Cassette do
               before(:each) { File.stub(:exist?).with(file_name).and_return(false) }
 
               it "has :#{record_mode} for the record mode" do
-                subject.record_mode.should eq(record_mode)
+                expect(subject.record_mode).to eq(record_mode)
               end
             end
 
@@ -273,7 +273,7 @@ describe VCR::Cassette do
                 ] end
 
                 it "has :#{record_mode} for the record mode" do
-                  subject.record_mode.should eq(record_mode)
+                  expect(subject.record_mode).to eq(record_mode)
                 end
               end
 
@@ -286,12 +286,12 @@ describe VCR::Cassette do
 
                 it "has :all for the record mode when there is an internet connection available" do
                   VCR::InternetConnection.stub(:available? => true)
-                  subject.record_mode.should eq(:all)
+                  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)
-                  subject.record_mode.should eq(record_mode)
+                  expect(subject.record_mode).to eq(record_mode)
                 end
               end
             end
@@ -305,35 +305,35 @@ describe VCR::Cassette do
 
           VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
           cassette = VCR::Cassette.new('with_localhost_requests', :record => record_mode)
-          cassette.send(:previously_recorded_interactions).map { |i| URI.parse(i.request.uri).host }.should eq(%w[example.com])
+          expect(cassette.send(:previously_recorded_interactions).map { |i| URI.parse(i.request.uri).host }).to eq(%w[example.com])
         end
 
         it "loads the recorded interactions from the library yml file" do
           VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
           cassette = VCR::Cassette.new('example', :record => record_mode)
 
-          cassette.should have(3).previously_recorded_interactions
+          expect(cassette).to have(3).previously_recorded_interactions
 
           i1, i2, i3 = *cassette.send(:previously_recorded_interactions)
 
-          i1.request.method.should eq(:get)
-          i1.request.uri.should eq('http://example.com/')
-          i1.response.body.should =~ /You have reached this web page by typing.+example\.com/
+          expect(i1.request.method).to eq(:get)
+          expect(i1.request.uri).to eq('http://example.com/')
+          expect(i1.response.body).to match(/You have reached this web page by typing.+example\.com/)
 
-          i2.request.method.should eq(:get)
-          i2.request.uri.should eq('http://example.com/foo')
-          i2.response.body.should =~ /foo was not found on this server/
+          expect(i2.request.method).to eq(:get)
+          expect(i2.request.uri).to eq('http://example.com/foo')
+          expect(i2.response.body).to match(/foo was not found on this server/)
 
-          i3.request.method.should eq(:get)
-          i3.request.uri.should eq('http://example.com/')
-          i3.response.body.should =~ /Another example\.com response/
+          expect(i3.request.method).to eq(:get)
+          expect(i3.request.uri).to eq('http://example.com/')
+          expect(i3.response.body).to match(/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)
+            expect(cassette.http_interactions.allow_playback_repeats).to eq(value)
           end
         end
 
@@ -341,14 +341,14 @@ describe VCR::Cassette 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(VCR::Cassette::HTTPInteractionList::NullList)
+          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)
           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)
+          expect(cassette.http_interactions.parent_list).to be(VCR.http_interactions)
         end
 
         if stub_requests
@@ -360,7 +360,7 @@ describe VCR::Cassette do
             ).exactly(3).times
 
             cassette = VCR::Cassette.new('example', :record => record_mode)
-            cassette.should have(3).previously_recorded_interactions
+            expect(cassette).to have(3).previously_recorded_interactions
           end
 
           it 'does not playback any interactions that are ignored in a before_playback hook' do
@@ -370,21 +370,21 @@ describe VCR::Cassette do
 
             VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
             cassette = VCR::Cassette.new('example', :record => record_mode)
-            cassette.should have(2).previously_recorded_interactions
+            expect(cassette).to have(2).previously_recorded_interactions
           end
 
           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 eq([:body, :headers])
+            expect(cassette.http_interactions.interactions).to have(3).interactions
+            expect(cassette.http_interactions.request_matchers).to eq([:body, :headers])
           end
         else
           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 eq([:body, :headers])
+            expect(cassette.http_interactions.interactions).to have(0).interactions
+            expect(cassette.http_interactions.request_matchers).to eq([:body, :headers])
           end
         end
       end
@@ -398,7 +398,7 @@ describe VCR::Cassette do
       cassette = VCR.insert_cassette("foo", :allow_unused_http_interactions => false)
 
       interaction_list = cassette.http_interactions
-      interaction_list.should respond_to(:assert_no_unused_interactions!).with(0).arguments
+      expect(interaction_list).to respond_to(:assert_no_unused_interactions!).with(0).arguments
       interaction_list.should_receive(:assert_no_unused_interactions!)
 
       cassette.eject
@@ -408,7 +408,7 @@ describe VCR::Cassette do
       cassette = VCR.insert_cassette("foo", :allow_unused_http_interactions => true)
 
       interaction_list = cassette.http_interactions
-      interaction_list.should respond_to(:assert_no_unused_interactions!)
+      expect(interaction_list).to respond_to(:assert_no_unused_interactions!)
       interaction_list.should_not_receive(:assert_no_unused_interactions!)
 
       cassette.eject
@@ -428,12 +428,12 @@ describe VCR::Cassette do
     it "writes the serializable_hash to disk as yaml" do
       cassette = VCR::Cassette.new(:eject_test)
       cassette.record_http_interaction http_interaction # so it has one
-      cassette.should respond_to(:serializable_hash)
+      expect(cassette).to respond_to(:serializable_hash)
       cassette.stub(:serializable_hash => { "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)
-      saved_stuff.should eq("http_interactions" => [1, 3, 5])
+      expect(saved_stuff).to eq("http_interactions" => [1, 3, 5])
     end
 
     it 'invokes the appropriately tagged before_record hooks' do
@@ -471,7 +471,7 @@ describe VCR::Cassette do
       cassette.eject
 
       saved_recorded_interactions = ::YAML.load_file(cassette.file)
-      saved_recorded_interactions["http_interactions"].should eq([interaction_2.to_hash])
+      expect(saved_recorded_interactions["http_interactions"]).to eq([interaction_2.to_hash])
     end
 
     it 'does not write the cassette to disk if all interactions have been ignored' do
@@ -485,7 +485,7 @@ describe VCR::Cassette do
       cassette.stub!(:new_recorded_interactions).and_return([interaction_1])
       cassette.eject
 
-      File.should_not exist(cassette.file)
+      expect(File).not_to exist(cassette.file)
     end
 
     it "writes the recorded interactions to a subdirectory if the cassette name includes a directory" do
@@ -495,7 +495,7 @@ describe VCR::Cassette do
 
       expect { cassette.eject }.to change { File.exist?(cassette.file) }.from(false).to(true)
       saved_recorded_interactions = YAML.load_file(cassette.file)
-      saved_recorded_interactions["http_interactions"].should eq(recorded_interactions.map(&:to_hash))
+      expect(saved_recorded_interactions["http_interactions"]).to eq(recorded_interactions.map(&:to_hash))
     end
 
     [:all, :none, :new_episodes].each do |record_mode|
@@ -540,16 +540,16 @@ describe VCR::Cassette do
 
           if record_mode == :all
             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)
+              expect(saved_recorded_interactions.first).to eq(interaction_foo_2)
+              expect(saved_recorded_interactions).not_to include(interaction_foo_1)
             end
 
             it 'appends new recorded interactions that do not match existing ones' do
-              saved_recorded_interactions.last.should eq(interaction_bar)
+              expect(saved_recorded_interactions.last).to eq(interaction_bar)
             end
           else
             it 'appends new recorded interactions after existing ones' do
-              saved_recorded_interactions.should eq([interaction_foo_1, interaction_foo_2, interaction_bar])
+              expect(saved_recorded_interactions).to eq([interaction_foo_1, interaction_foo_2, interaction_bar])
             end
           end
         end

data/spec/vcr/configuration_spec.rb

@@ -17,13 +17,13 @@ describe VCR::Configuration do
       relative_dir = 'tmp/cassette_library_dir/new_dir'
       subject.cassette_library_dir = relative_dir
       absolute_dir = File.join(VCR::SPEC_ROOT.sub(/\/spec\z/, ''), relative_dir)
-      subject.cassette_library_dir.should eq(absolute_dir)
+      expect(subject.cassette_library_dir).to eq(absolute_dir)
     end
   end
 
   describe '#default_cassette_options' do
     it 'has a hash with some defaults' do
-      subject.default_cassette_options.should eq({
+      expect(subject.default_cassette_options).to eq({
         :match_requests_on => VCR::RequestMatcherRegistry::DEFAULT_MATCHERS,
         :allow_unused_http_interactions => true,
         :record            => :once,
@@ -34,22 +34,22 @@ describe VCR::Configuration do
 
     it "returns #{VCR::RequestMatcherRegistry::DEFAULT_MATCHERS.inspect} for :match_requests_on when other defaults have been set" do
       subject.default_cassette_options = { :record => :none }
-      subject.default_cassette_options.should include(:match_requests_on => VCR::RequestMatcherRegistry::DEFAULT_MATCHERS)
+      expect(subject.default_cassette_options).to include(:match_requests_on => VCR::RequestMatcherRegistry::DEFAULT_MATCHERS)
     end
 
     it "returns :once for :record when other defaults have been set" do
       subject.default_cassette_options = { :erb => :true }
-      subject.default_cassette_options.should include(:record => :once)
+      expect(subject.default_cassette_options).to include(:record => :once)
     end
 
     it "allows defaults to be overriden" do
       subject.default_cassette_options = { :record => :all }
-      subject.default_cassette_options.should include(:record => :all)
+      expect(subject.default_cassette_options).to include(:record => :all)
     end
 
     it "allows other keys to be set" do
       subject.default_cassette_options = { :re_record_interval => 10 }
-      subject.default_cassette_options.should include(:re_record_interval => 10)
+      expect(subject.default_cassette_options).to include(:re_record_interval => 10)
     end
   end
 
@@ -62,7 +62,7 @@ describe VCR::Configuration do
       matcher_run = false
       subject.register_request_matcher(:custom) { |r1, r2| matcher_run = true }
       VCR.request_matchers[:custom].matches?(:r1, :r2)
-      matcher_run.should be_true
+      expect(matcher_run).to be_true
     end
   end
 
@@ -83,7 +83,7 @@ describe VCR::Configuration do
       called = false
       subject.after_library_hooks_loaded { called = true }
       subject.hook_into :fakeweb
-      called.should be_true
+      expect(called).to be_true
     end
   end
 
@@ -108,7 +108,7 @@ describe VCR::Configuration do
       block_called = false
       subject.ignore_request { |r| block_called = true }
       VCR.request_ignorer.ignore?(stub(:parsed_uri => uri))
-      block_called.should be_true
+      expect(block_called).to be_true
     end
   end
 
@@ -116,7 +116,7 @@ describe VCR::Configuration do
     [true, false].each do |val|
       it "sets the allow_http_connections_when_no_cassette to #{val} when set to #{val}" do
         subject.allow_http_connections_when_no_cassette = val
-        subject.allow_http_connections_when_no_cassette?.should eq(val)
+        expect(subject.allow_http_connections_when_no_cassette?).to eq(val)
       end
     end
   end
@@ -133,8 +133,8 @@ describe VCR::Configuration do
         ::Net::HTTP.get_response(URI("http://localhost:#{VCR::SinatraApp.port}/foo"))
       end
 
-      before_record_req.should_not respond_to(:type)
-      before_request_req.should respond_to(:type)
+      expect(before_record_req).not_to respond_to(:type)
+      expect(before_request_req).to respond_to(:type)
     end unless (RUBY_VERSION =~ /^1\.8/ || RUBY_INTERPRETER == :jruby)
 
     specify 'the filter_sensitive_data option works even when it modifies the URL in a way that makes it an invalid URI' do
@@ -156,9 +156,9 @@ describe VCR::Configuration do
         called = false
         VCR.configuration.send(hook_type, :my_tag) { called = true }
         VCR.configuration.invoke_hook(hook_type, stub, stub(:tags => []))
-        called.should be_false
+        expect(called).to be_false
         VCR.configuration.invoke_hook(hook_type, stub, stub(:tags => [:my_tag]))
-        called.should be_true
+        expect(called).to be_true
       end
     end
   end
@@ -194,14 +194,14 @@ describe VCR::Configuration do
         yielded_interaction = nil
         subject.send(method, 'foo', &lambda { |i| yielded_interaction = i; 'bar' })
         subject.invoke_hook(:before_record, interaction, stub.as_null_object)
-        yielded_interaction.should equal(interaction)
+        expect(yielded_interaction).to equal(interaction)
       end
 
       it 'yields the interaction to the block for the before_playback hook' do
         yielded_interaction = nil
         subject.send(method, 'foo', &lambda { |i| yielded_interaction = i; 'bar' })
         subject.invoke_hook(:before_playback, interaction, stub.as_null_object)
-        yielded_interaction.should equal(interaction)
+        expect(yielded_interaction).to equal(interaction)
       end
     end
   end
@@ -218,11 +218,11 @@ describe VCR::Configuration do
       yielded = false
       subject.after_http_request(:stubbed_by_vcr?) { |req| yielded = true }
       subject.invoke_hook(:after_http_request, request(:stubbed_by_vcr), response)
-      yielded.should be_true
+      expect(yielded).to be_true
 
       yielded = false
       subject.invoke_hook(:after_http_request, request(:ignored), response)
-      yielded.should be_false
+      expect(yielded).to be_false
     end
   end
 
@@ -239,7 +239,7 @@ describe VCR::Configuration do
     it 'allows a custom serializer to be registered' do
       expect { subject.cassette_serializers[:custom] }.to raise_error(ArgumentError)
       subject.cassette_serializers[:custom] = custom_serializer
-      subject.cassette_serializers[:custom].should be(custom_serializer)
+      expect(subject.cassette_serializers[:custom]).to be(custom_serializer)
     end
   end
 
@@ -248,7 +248,7 @@ describe VCR::Configuration do
     it 'allows a custom persister to be registered' do
       expect { subject.cassette_persisters[:custom] }.to raise_error(ArgumentError)
       subject.cassette_persisters[:custom] = custom_persister
-      subject.cassette_persisters[:custom].should be(custom_persister)
+      expect(subject.cassette_persisters[:custom]).to be(custom_persister)
     end
   end
 
@@ -256,11 +256,11 @@ describe VCR::Configuration do
     let(:custom_parser) { stub }
     it 'allows a custom uri parser to be set' do
       subject.uri_parser = custom_parser
-      subject.uri_parser.should eq(custom_parser)
+      expect(subject.uri_parser).to eq(custom_parser)
     end
 
     it "uses Ruby's standard library `URI` as a default" do
-      subject.uri_parser.should eq(URI)
+      expect(subject.uri_parser).to eq(URI)
     end
   end
 
@@ -271,43 +271,55 @@ describe VCR::Configuration do
 
     context "default hook" do
       it "returns false when there is no current cassette" do
-        subject.preserve_exact_body_bytes_for?(message_for "string").should be_false
+        expect(subject.preserve_exact_body_bytes_for?(message_for "string")).to be_false
       end
 
       it "returns false when the current cassette has been created without the :preserve_exact_body_bytes option" do
         VCR.insert_cassette('foo')
-        subject.preserve_exact_body_bytes_for?(message_for "string").should be_false
+        expect(subject.preserve_exact_body_bytes_for?(message_for "string")).to be_false
       end
 
       it 'returns true when the current cassette has been created with the :preserve_exact_body_bytes option' do
         VCR.insert_cassette('foo', :preserve_exact_body_bytes => true)
-        subject.preserve_exact_body_bytes_for?(message_for "string").should be_true
+        expect(subject.preserve_exact_body_bytes_for?(message_for "string")).to be_true
       end
     end
 
     it "returns true when the configured block returns true" do
       subject.preserve_exact_body_bytes { |msg| msg.body == "a" }
-      subject.preserve_exact_body_bytes_for?(message_for "a").should be_true
-      subject.preserve_exact_body_bytes_for?(message_for "b").should be_false
+      expect(subject.preserve_exact_body_bytes_for?(message_for "a")).to be_true
+      expect(subject.preserve_exact_body_bytes_for?(message_for "b")).to be_false
     end
 
     it "returns true when any of the registered blocks returns true" do
       called_hooks = []
       subject.preserve_exact_body_bytes { called_hooks << :hook_1; false }
       subject.preserve_exact_body_bytes { called_hooks << :hook_2; true }
-      subject.preserve_exact_body_bytes_for?(message_for "a").should be_true
-      called_hooks.should eq([:hook_1, :hook_2])
+      expect(subject.preserve_exact_body_bytes_for?(message_for "a")).to be_true
+      expect(called_hooks).to eq([:hook_1, :hook_2])
     end
 
     it "invokes the configured hook with the http message and the current cassette" do
       VCR.use_cassette('example') do |cassette|
-        cassette.should be_a(VCR::Cassette)
+        expect(cassette).to be_a(VCR::Cassette)
         message = stub(:message)
 
         yielded_objects = nil
         subject.preserve_exact_body_bytes { |a, b| yielded_objects = [a, b] }
         subject.preserve_exact_body_bytes_for?(message)
-        yielded_objects.should eq([message, cassette])
+        expect(yielded_objects).to eq([message, cassette])
+      end
+    end
+  end
+
+  describe "#configure_rspec_metadata!" do
+    it "only configures the underlying metadata once, no matter how many times it is called" do
+      VCR::RSpec::Metadata.should_receive(:configure!).once
+      VCR.configure do |c|
+        c.configure_rspec_metadata!
+      end
+      VCR.configure do |c|
+        c.configure_rspec_metadata!
       end
     end
   end