vcr 2.4.0 → 2.5.0

data/spec/vcr/test_frameworks/cucumber_spec.rb

@@ -21,13 +21,13 @@ describe VCR::CucumberTags do
   end
 
   def test_tag(cassette_attribute, tag, expected_value, scenario=current_scenario)
-    VCR.current_cassette.should be_nil
+    expect(VCR.current_cassette).to be_nil
 
     before_blocks_for_tags[tag].call(scenario)
-    VCR.current_cassette.send(cassette_attribute).should eq(expected_value)
+    expect(VCR.current_cassette.send(cassette_attribute)).to eq(expected_value)
     after_blocks_for_tags[tag].call(scenario)
 
-    VCR.current_cassette.should be_nil
+    expect(VCR.current_cassette).to be_nil
   end
 
   %w(tags tag).each do |tag_method|
@@ -82,9 +82,9 @@ describe VCR::CucumberTags do
           subject.send(tag_method, 'tag1', original_options)
           before_blocks_for_tags['tag1'].call(current_scenario)
 
-          original_options.should have(2).items
-          original_options[:use_scenario_name].should eq(true)
-          original_options[:record].should eq(:none)
+          expect(original_options).to have(2).items
+          expect(original_options[:use_scenario_name]).to eq(true)
+          expect(original_options[:record]).to eq(:none)
         end
 
         it "works properly when multiple scenarios use the tag" do
@@ -101,7 +101,7 @@ describe VCR::CucumberTags do
     it 'returns the list of cucumber tags' do
       subject.tags 'tag1', 'tag2'
       subject.tags 'tag3', 'tag4'
-      described_class.tags[-4, 4].should eq(%w(@tag1 @tag2 @tag3 @tag4))
+      expect(described_class.tags[-4, 4]).to eq(%w(@tag1 @tag2 @tag3 @tag4))
     end
   end
 end

data/spec/vcr/test_frameworks/rspec_spec.rb

@@ -9,7 +9,7 @@ describe VCR::RSpec::Metadata, :skip_vcr_reset do
   context 'an example group', :vcr do
     context 'with a nested example group' do
       it 'uses a cassette for any examples' do
-        VCR.current_cassette.name.split('/').should eq([
+        expect(VCR.current_cassette.name.split('/')).to eq([
           'VCR::RSpec::Metadata',
           'an example group',
           'with a nested example group',
@@ -21,20 +21,20 @@ describe VCR::RSpec::Metadata, :skip_vcr_reset do
 
   context 'with the cassette name overridden at the example group level', :vcr => { :cassette_name => 'foo' } do
     it 'overrides the cassette name for an example' do
-      VCR.current_cassette.name.should eq('foo')
+      expect(VCR.current_cassette.name).to eq('foo')
     end
 
     it 'overrides the cassette name for another example' do
-      VCR.current_cassette.name.should eq('foo')
+      expect(VCR.current_cassette.name).to eq('foo')
     end
   end
 
   it 'allows the cassette name to be overriden', :vcr => { :cassette_name => 'foo' } do
-    VCR.current_cassette.name.should eq('foo')
+    expect(VCR.current_cassette.name).to eq('foo')
   end
 
   it 'allows the cassette options to be set', :vcr => { :match_requests_on => [:method] } do
-    VCR.current_cassette.match_requests_on.should eq([:method])
+    expect(VCR.current_cassette.match_requests_on).to eq([:method])
   end
 end
 
@@ -46,18 +46,18 @@ describe VCR::RSpec::Macros do
       context context_name do
         after(:each) do
           if example.metadata[:test_ejection]
-            VCR.current_cassette.should be_nil
+            expect(VCR.current_cassette).to be_nil
           end
         end
 
         use_vcr_cassette(*args)
 
         it 'ejects the cassette in an after hook', :test_ejection do
-          VCR.current_cassette.should be_a(VCR::Cassette)
+          expect(VCR.current_cassette).to be_a(VCR::Cassette)
         end
 
         it "creates a cassette named '#{expected_cassette_name}" do
-          VCR.current_cassette.name.should eq(expected_cassette_name)
+          expect(VCR.current_cassette.name).to eq(expected_cassette_name)
         end
 
         module_eval(&block) if block
@@ -68,7 +68,7 @@ describe VCR::RSpec::Macros do
 
     perform_test 'when called with an explicit name and some options', 'explicit_name', 'explicit_name', :match_requests_on => [:method, :host] do
       it 'uses the provided cassette options' do
-        VCR.current_cassette.match_requests_on.should eq([:method, :host])
+        expect(VCR.current_cassette.match_requests_on).to eq([:method, :host])
       end
     end
 
@@ -76,7 +76,7 @@ describe VCR::RSpec::Macros do
 
     perform_test 'when called with some options', 'VCR::RSpec::Macros/#use_vcr_cassette/when called with some options', :match_requests_on => [:method, :host] do
       it 'uses the provided cassette options' do
-        VCR.current_cassette.match_requests_on.should eq([:method, :host])
+        expect(VCR.current_cassette.match_requests_on).to eq([:method, :host])
       end
     end
   end

data/spec/vcr/util/hooks_spec.rb

@@ -6,21 +6,21 @@ describe VCR::Hooks::FilteredHook do
       called = false
       subject.hook = lambda { called = true }
       subject.conditionally_invoke
-      called.should be_true
+      expect(called).to be_true
     end
 
     it 'forwards the given arguments to the hook' do
       args = nil
       subject.hook = lambda { |a, b| args = [a, b] }
       subject.conditionally_invoke(3, 5)
-      args.should eq([3, 5])
+      expect(args).to eq([3, 5])
     end
 
     it 'forwards only as many arguments as the hook block accepts' do
       args = nil
       subject.hook = lambda { |a| args = [a] }
       subject.conditionally_invoke(3, 5)
-      args.should eq([3])
+      expect(args).to eq([3])
     end
 
     it 'does not invoke the hook if all of the filters return false' do
@@ -28,7 +28,7 @@ describe VCR::Hooks::FilteredHook do
       subject.hook = lambda { called = true }
       subject.filters = lambda { false }
       subject.conditionally_invoke
-      called.should be_false
+      expect(called).to be_false
     end
 
     it 'does not invoke the hook if any of the filters returns false' do
@@ -36,21 +36,21 @@ describe VCR::Hooks::FilteredHook do
       subject.hook = lambda { called = true }
       subject.filters = [lambda { false }, lambda { true }]
       subject.conditionally_invoke
-      called.should be_false
+      expect(called).to be_false
     end
 
     it 'forwards arguments to the filters' do
       filter_args = nil
       subject.filters = lambda { |a, b| filter_args = [a, b]; false }
       subject.conditionally_invoke(3, 5)
-      filter_args.should eq([3, 5])
+      expect(filter_args).to eq([3, 5])
     end
 
     it 'handles splat args properly' do
       filter_args = nil
       subject.filters = lambda { |*args| filter_args = args; false }
       subject.conditionally_invoke(3, 5)
-      filter_args.should eq([3, 5])
+      expect(filter_args).to eq([3, 5])
     end
 
     it 'forwards only as many arguments as the filter blocks accept' do
@@ -61,8 +61,8 @@ describe VCR::Hooks::FilteredHook do
       ]
 
       subject.conditionally_invoke(3, 5)
-      args1.should eq([3])
-      args2.should eq([3, 5])
+      expect(args1).to eq([3])
+      expect(args2).to eq([3, 5])
     end
 
     it '#to_procs the filter objects' do
@@ -70,7 +70,7 @@ describe VCR::Hooks::FilteredHook do
       subject.hook = lambda { }
       subject.filters = [stub(:to_proc => lambda { filter_called = true })]
       subject.conditionally_invoke
-      filter_called.should be_true
+      expect(filter_called).to be_true
     end
   end
 end
@@ -99,7 +99,7 @@ describe VCR::Hooks do
     end
 
     subject.before_foo { }
-    override_called.should be_true
+    expect(override_called).to be_true
   end
 
   describe '#clear_hooks' do
@@ -107,7 +107,7 @@ describe VCR::Hooks do
       subject.before_foo { invocations << :callback }
       subject.clear_hooks
       subject.invoke_hook(:before_foo)
-      invocations.should be_empty
+      expect(invocations).to be_empty
     end
   end
 
@@ -116,42 +116,42 @@ describe VCR::Hooks do
       subject.before_foo { invocations << :callback_1 }
       subject.before_foo { invocations << :callback_2 }
 
-      invocations.should be_empty
+      expect(invocations).to be_empty
       subject.invoke_hook(:before_foo)
-      invocations.should eq([:callback_1, :callback_2])
+      expect(invocations).to eq([:callback_1, :callback_2])
     end
 
     it 'maps the return value of each callback' do
       subject.before_foo { 17 }
       subject.before_foo { 12 }
-      subject.invoke_hook(:before_foo).should eq([17, 12])
+      expect(subject.invoke_hook(:before_foo)).to eq([17, 12])
     end
 
     it 'does not invoke any filtered callbacks' do
       subject.before_foo(:real?) { invocations << :blue_callback }
       subject.invoke_hook(:before_foo, stub(:real? => false))
-      invocations.should be_empty
+      expect(invocations).to be_empty
     end
 
     it 'invokes them in reverse order if the hook was defined with :prepend' do
       subject.before_bar { 17 }
       subject.before_bar { 12 }
-      subject.invoke_hook(:before_bar).should eq([12, 17])
+      expect(subject.invoke_hook(:before_bar)).to eq([12, 17])
     end
   end
 
   describe "#has_hooks_for?" do
     it 'returns false when given an unrecognized hook name' do
-      subject.should_not have_hooks_for(:abcd)
+      expect(subject).not_to have_hooks_for(:abcd)
     end
 
     it 'returns false when given the name of a defined hook that has no registered callbacks' do
-      subject.should_not have_hooks_for(:before_foo)
+      expect(subject).not_to have_hooks_for(:before_foo)
     end
 
     it 'returns true when given the name of a defined hook that has registered callbacks' do
       subject.before_foo { }
-      subject.should have_hooks_for(:before_foo)
+      expect(subject).to have_hooks_for(:before_foo)
     end
   end
 end

data/spec/vcr/util/internet_connection_spec.rb

@@ -13,7 +13,7 @@ describe VCR::InternetConnection do
     context 'when pinging example.com succeeds' do
       it 'returns true' do
         stub_pingecho_with(true)
-        described_class.should be_available
+        expect(described_class).to be_available
       end
 
       it 'memoizes the value so no extra pings are made' do
@@ -25,7 +25,7 @@ describe VCR::InternetConnection do
     context 'when pinging example.com fails' do
       it 'returns false' do
         stub_pingecho_with(false)
-        described_class.should_not be_available
+        expect(described_class).not_to be_available
       end
 
       it 'memoizes the value so no extra pings are made' do

data/spec/vcr_spec.rb

@@ -7,14 +7,14 @@ describe VCR do
 
   describe '.insert_cassette' do
     it 'creates a new cassette' do
-      insert_cassette.should be_instance_of(VCR::Cassette)
+      expect(insert_cassette).to be_instance_of(VCR::Cassette)
     end
 
     it 'takes over as the #current_cassette' do
       orig_cassette = VCR.current_cassette
       new_cassette = insert_cassette
-      new_cassette.should_not eq(orig_cassette)
-      VCR.current_cassette.should eq(new_cassette)
+      expect(new_cassette).not_to eq(orig_cassette)
+      expect(VCR.current_cassette).to eq(new_cassette)
     end
 
     it 'raises an error if the stack of inserted cassettes already contains a cassette with the same name' do
@@ -34,7 +34,7 @@ describe VCR do
 
     it 'returns the ejected cassette' do
       cassette = insert_cassette
-      VCR.eject_cassette.should eq(cassette)
+      expect(VCR.eject_cassette).to eq(cassette)
     end
 
     it 'returns the #current_cassette to the previous one' do
@@ -49,15 +49,15 @@ describe VCR do
 
       VCR.eject_cassette
 
-      current.should be(cassette)
-      VCR.current_cassette.should_not be(cassette)
+      expect(current).to be(cassette)
+      expect(VCR.current_cassette).not_to be(cassette)
     end
 
     it 'properly pops the cassette off the stack even if an error occurs' do
       cassette = insert_cassette
       cassette.stub(:eject) { raise "boom" }
       expect { VCR.eject_cassette }.to raise_error("boom")
-      VCR.current_cassette.should be_nil
+      expect(VCR.current_cassette).to be_nil
     end
   end
 
@@ -71,19 +71,19 @@ describe VCR do
     it 'yields' do
       yielded = false
       VCR.use_cassette(:cassette_test, &lambda { yielded = true })
-      yielded.should be_true
+      expect(yielded).to be_true
     end
 
     it 'yields the cassette instance if the block expects an argument' do
       VCR.use_cassette('name', :record => :new_episodes, &lambda do |cassette|
-        cassette.should equal(VCR.current_cassette)
+        expect(cassette).to equal(VCR.current_cassette)
       end)
     end
 
     it 'yields the cassette instance if the block expects a variable number of args' do
       VCR.use_cassette('name', :record => :new_episodes) do |*args|
-        args.size.should eq(1)
-        args.first.should equal(VCR.current_cassette)
+        expect(args.size).to eq(1)
+        expect(args.first).to equal(VCR.current_cassette)
       end
     end
 
@@ -113,12 +113,12 @@ describe VCR do
   describe '.http_interactions' do
     it 'returns the current_cassette.http_interactions when there is a current cassette' do
       cassette = VCR.insert_cassette("a cassette")
-      VCR.http_interactions.should be(cassette.http_interactions)
+      expect(VCR.http_interactions).to be(cassette.http_interactions)
     end
 
     it 'returns a null list when there is no current cassette' do
-      VCR.current_cassette.should be_nil
-      VCR.http_interactions.should be(VCR::Cassette::HTTPInteractionList::NullList)
+      expect(VCR.current_cassette).to be_nil
+      expect(VCR.http_interactions).to be(VCR::Cassette::HTTPInteractionList::NullList)
     end
   end
 
@@ -126,82 +126,84 @@ describe VCR do
     context 'when a cassette is inserted' do
       it 'returns true if the cassette is recording' do
         VCR.insert_cassette('foo', :record => :all)
-        VCR.current_cassette.should be_recording
-        VCR.real_http_connections_allowed?.should be_true
+        expect(VCR.current_cassette).to be_recording
+        expect(VCR.real_http_connections_allowed?).to be_true
       end
 
       it 'returns false if the cassette is not recording' do
         VCR.insert_cassette('foo', :record => :none)
-        VCR.current_cassette.should_not be_recording
-        VCR.real_http_connections_allowed?.should be_false
+        expect(VCR.current_cassette).not_to be_recording
+        expect(VCR.real_http_connections_allowed?).to be_false
       end
     end
 
     context 'when no cassette is inserted' do
-      before(:each) { VCR.current_cassette.should be_nil }
+      before(:each) do
+        expect(VCR.current_cassette).to be_nil
+      end
 
       it 'returns true if the allow_http_connections_when_no_cassette option is set to true' do
-        VCR.should be_turned_on
+        expect(VCR).to be_turned_on
         VCR.configure { |c| c.allow_http_connections_when_no_cassette = true }
-        VCR.real_http_connections_allowed?.should be_true
+        expect(VCR.real_http_connections_allowed?).to be_true
       end
 
       it 'returns true if VCR is turned off' do
         VCR.turn_off!
         VCR.configure { |c| c.allow_http_connections_when_no_cassette = false }
-        VCR.real_http_connections_allowed?.should be_true
+        expect(VCR.real_http_connections_allowed?).to be_true
       end
 
       it 'returns false if the allow_http_connections_when_no_cassette option is set to false and VCR is turned on' do
-        VCR.should be_turned_on
+        expect(VCR).to be_turned_on
         VCR.configure { |c| c.allow_http_connections_when_no_cassette = false }
-        VCR.real_http_connections_allowed?.should be_false
+        expect(VCR.real_http_connections_allowed?).to be_false
       end
     end
   end
 
   describe '.request_matchers' do
     it 'always returns the same memoized request matcher registry instance' do
-      VCR.request_matchers.should be_a(VCR::RequestMatcherRegistry)
-      VCR.request_matchers.should be(VCR.request_matchers)
+      expect(VCR.request_matchers).to be_a(VCR::RequestMatcherRegistry)
+      expect(VCR.request_matchers).to be(VCR.request_matchers)
     end
   end
 
   describe '.request_ignorer' do
     it 'always returns the same memoized request ignorer instance' do
-      VCR.request_ignorer.should be_a(VCR::RequestIgnorer)
-      VCR.request_ignorer.should be(VCR.request_ignorer)
+      expect(VCR.request_ignorer).to be_a(VCR::RequestIgnorer)
+      expect(VCR.request_ignorer).to be(VCR.request_ignorer)
     end
   end
 
   describe '.library_hooks' do
     it 'always returns the same memoized LibraryHooks instance' do
-      VCR.library_hooks.should be_a(VCR::LibraryHooks)
-      VCR.library_hooks.should be(VCR.library_hooks)
+      expect(VCR.library_hooks).to be_a(VCR::LibraryHooks)
+      expect(VCR.library_hooks).to be(VCR.library_hooks)
     end
   end
 
   describe '.cassette_serializers' do
     it 'always returns the same memoized cassette serializers instance' do
-      VCR.cassette_serializers.should be_a(VCR::Cassette::Serializers)
-      VCR.cassette_serializers.should be(VCR.cassette_serializers)
+      expect(VCR.cassette_serializers).to be_a(VCR::Cassette::Serializers)
+      expect(VCR.cassette_serializers).to be(VCR.cassette_serializers)
     end
   end
 
   describe ".cassette_persisters" do
     it "always returns the same memoized Cassette::Persisters instance" do
-      VCR.cassette_persisters.should be_a(VCR::Cassette::Persisters)
-      VCR.cassette_persisters.should be(VCR.cassette_persisters)
+      expect(VCR.cassette_persisters).to be_a(VCR::Cassette::Persisters)
+      expect(VCR.cassette_persisters).to be(VCR.cassette_persisters)
     end
   end
 
   describe '.configuration' do
     it 'returns the configuration object' do
-      VCR.configuration.should be_a(VCR::Configuration)
+      expect(VCR.configuration).to be_a(VCR::Configuration)
     end
 
     it 'memoizes the instance' do
-      VCR.configuration.should be(VCR.configuration)
+      expect(VCR.configuration).to be(VCR.configuration)
     end
   end
 
@@ -211,7 +213,7 @@ describe VCR do
       VCR.configure do |obj|
         yielded_object = obj
       end
-      yielded_object.should eq(VCR.configuration)
+      expect(yielded_object).to eq(VCR.configuration)
     end
   end
 
@@ -221,7 +223,7 @@ describe VCR do
       VCR.cucumber_tags do |obj|
         yielded_object = obj
       end
-      yielded_object.should be_instance_of(VCR::CucumberTags)
+      expect(yielded_object).to be_instance_of(VCR::CucumberTags)
     end
   end
 
@@ -259,7 +261,7 @@ describe VCR do
   describe '.turn_off!' do
     it 'indicates it is turned off' do
       VCR.turn_off!
-      VCR.should_not be_turned_on
+      expect(VCR).not_to be_turned_on
     end
 
     it 'raises an error if a cassette is in use' do
@@ -287,7 +289,7 @@ describe VCR do
 
       it 'ignores cassette insertions' do
         VCR.insert_cassette('foo')
-        VCR.current_cassette.should be_nil
+        expect(VCR.current_cassette).to be_nil
       end
 
       it 'still runs a block passed to use_cassette' do
@@ -295,10 +297,10 @@ describe VCR do
 
         VCR.use_cassette('foo') do
           yielded = true
-          VCR.current_cassette.should be_nil
+          expect(VCR.current_cassette).to be_nil
         end
 
-        yielded.should be_true
+        expect(yielded).to be_true
       end
     end
   end
@@ -308,22 +310,22 @@ describe VCR do
 
     it 'indicates it is turned on' do
       VCR.turn_on!
-      VCR.should be_turned_on
+      expect(VCR).to be_turned_on
     end
   end
 
   describe '.turned_off' do
     it 'yields with VCR turned off' do
-      VCR.should be_turned_on
+      expect(VCR).to be_turned_on
       yielded = false
 
       VCR.turned_off do
         yielded = true
-        VCR.should_not be_turned_on
+        expect(VCR).not_to be_turned_on
       end
 
-      yielded.should eq(true)
-      VCR.should be_turned_on
+      expect(yielded).to eq(true)
+      expect(VCR).to be_turned_on
     end
 
     it 'passes options through to .turn_off!' do
@@ -335,7 +337,7 @@ describe VCR do
   describe '.turned_on?' do
     it 'is on by default' do
       VCR.send(:initialize_ivars) # clear internal state
-      VCR.should be_turned_on
+      expect(VCR).to be_turned_on
     end
   end
 end