vcr 2.4.0 → 2.5.0

data/spec/support/shared_example_groups/request_hooks.rb

@@ -6,8 +6,8 @@ shared_examples_for "request hooks" do |library_hook_name, request_type|
   end
 
   def assert_expected_response(response)
-    response.status.code.should eq(200)
-    response.body.should eq('FOO!')
+    expect(response.status.code).to eq(200)
+    expect(response.body).to eq('FOO!')
   end
 
   [:before_http_request, :after_http_request].each do |hook|
@@ -16,7 +16,7 @@ shared_examples_for "request hooks" do |library_hook_name, request_type|
       VCR.configuration.send(hook) { |r| call_count += 1 }
 
       make_request
-      call_count.should eq(1)
+      expect(call_count).to eq(1)
     end
 
     specify "the #{hook} hook yields the request" do
@@ -24,19 +24,19 @@ shared_examples_for "request hooks" do |library_hook_name, request_type|
       VCR.configuration.send(hook) { |r| request = r }
 
       make_request
-      request.method.should be(:get)
-      request.uri.should eq(request_url)
+      expect(request.method).to be(:get)
+      expect(request.uri).to eq(request_url)
     end
 
     specify "the #{hook} hook is not called if the library hook is disabled" do
-      VCR.library_hooks.should respond_to(:disabled?)
+      expect(VCR.library_hooks).to respond_to(:disabled?)
       VCR.library_hooks.stub(:disabled? => true)
 
       hook_called = false
       VCR.configuration.send(hook) { |r| hook_called = true }
 
       make_request(:disabled)
-      hook_called.should be_false
+      expect(hook_called).to be_false
     end
 
     specify "the #type of the yielded request given to the #{hook} hook is #{request_type}" do
@@ -44,7 +44,7 @@ shared_examples_for "request hooks" do |library_hook_name, request_type|
       VCR.configuration.send(hook) { |r| request = r }
 
       make_request
-      request.type.should be(request_type)
+      expect(request.type).to be(request_type)
     end
   end
 

data/spec/vcr/cassette/erb_renderer_spec.rb

@@ -11,14 +11,14 @@ describe VCR::Cassette::ERBRenderer do
 
     context 'when ERB is disabled' do
       it 'returns the given template' do
-        render(no_vars_content, false).should eq(no_vars_content)
-        render(no_vars_content, nil).should eq(no_vars_content)
+        expect(render(no_vars_content, false)).to eq(no_vars_content)
+        expect(render(no_vars_content, nil)).to eq(no_vars_content)
       end
     end
 
     context 'when ERB is enabled but no variables are passed' do
       it 'renders the file content as ERB' do
-        render(no_vars_content, true).should eq("7. Some ERB")
+        expect(render(no_vars_content, true)).to eq("7. Some ERB")
       end
 
       it 'raises an appropriate error when the ERB template needs variables' do
@@ -31,13 +31,13 @@ describe VCR::Cassette::ERBRenderer do
       end
 
       it 'gracefully handles the template being nil' do
-        render(nil, true).should be_nil
+        expect(render(nil, true)).to be_nil
       end
     end
 
     context 'when ERB is enabled and variables are passed' do
       it 'renders the file content as ERB with the passed variables' do
-        render(vars_content, :var1 => 'foo', :var2 => 'bar').should eq('foo. ERB with Vars! bar')
+        expect(render(vars_content, :var1 => 'foo', :var2 => 'bar')).to eq('foo. ERB with Vars! bar')
       end
 
       it 'raises an appropriate error when one or more of the needed variables are not passed' do

data/spec/vcr/cassette/http_interaction_list_spec.rb

@@ -47,41 +47,41 @@ module VCR
 
       describe "#has_used_interaction_matching?" do
         it 'returns false when no interactions have been used' do
-          list.should_not have_used_interaction_matching(request_with(:method => :put))
+          expect(list).not_to have_used_interaction_matching(request_with(:method => :put))
         end
 
         it 'returns true when there is a matching used interaction (even if there is also an unused one that matches)' do
           list.response_for(request_with(:method => :post))
-          list.should have_used_interaction_matching(request_with(:method => :post))
+          expect(list).to have_used_interaction_matching(request_with(:method => :post))
         end
 
         it 'returns false when none of the used interactions match' do
           list.response_for(request_with(:method => :put))
-          list.should_not have_used_interaction_matching(request_with(:method => :post))
+          expect(list).not_to have_used_interaction_matching(request_with(:method => :post))
         end
       end
 
       describe "#remaining_unused_interaction_count" do
         it 'returns the number of unused interactions' do
-          list.remaining_unused_interaction_count.should eq(3)
+          expect(list.remaining_unused_interaction_count).to eq(3)
 
           list.response_for(request_with(:method => :get))
-          list.remaining_unused_interaction_count.should eq(3)
+          expect(list.remaining_unused_interaction_count).to eq(3)
 
           list.response_for(request_with(:method => :put))
-          list.remaining_unused_interaction_count.should eq(2)
+          expect(list.remaining_unused_interaction_count).to eq(2)
 
           list.response_for(request_with(:method => :put))
-          list.remaining_unused_interaction_count.should eq(2)
+          expect(list.remaining_unused_interaction_count).to eq(2)
 
           list.response_for(request_with(:method => :post))
-          list.remaining_unused_interaction_count.should eq(1)
+          expect(list.remaining_unused_interaction_count).to eq(1)
 
           list.response_for(request_with(:method => :post))
-          list.remaining_unused_interaction_count.should eq(0)
+          expect(list.remaining_unused_interaction_count).to eq(0)
 
           list.response_for(request_with(:method => :post))
-          list.remaining_unused_interaction_count.should eq(0)
+          expect(list.remaining_unused_interaction_count).to eq(0)
         end
       end
 
@@ -102,22 +102,22 @@ module VCR
 
       describe "has_interaction_matching?" do
         it 'returns false when the list is empty' do
-          HTTPInteractionList.new([], [:method]).should_not have_interaction_matching(stub)
+          expect(HTTPInteractionList.new([], [:method])).not_to have_interaction_matching(stub)
         end
 
         it 'returns false when there is no matching interaction' do
-          list.should_not have_interaction_matching(request_with(:method => :get))
+          expect(list).not_to have_interaction_matching(request_with(:method => :get))
         end
 
         it 'returns true when there is a matching interaction' do
-          list.should have_interaction_matching(request_with(:method => :post))
+          expect(list).to have_interaction_matching(request_with(:method => :post))
         end
 
         it 'does not consume the interactions when they match' do
-          list.should have_interaction_matching(request_with(:method => :post))
-          list.remaining_unused_interaction_count.should eq(3)
-          list.should have_interaction_matching(request_with(:method => :post))
-          list.remaining_unused_interaction_count.should eq(3)
+          expect(list).to have_interaction_matching(request_with(:method => :post))
+          expect(list.remaining_unused_interaction_count).to eq(3)
+          expect(list).to have_interaction_matching(request_with(:method => :post))
+          expect(list.remaining_unused_interaction_count).to eq(3)
         end
 
         it 'invokes each matcher block to find the matching interaction' do
@@ -131,15 +131,15 @@ module VCR
             interaction('response', :method => :put)
           ], [:foo, :bar, :baz])
 
-          list.should_not have_interaction_matching(request_with(:method => :post))
-          list.should     have_interaction_matching(request_with(:method => :post))
+          expect(list).not_to have_interaction_matching(request_with(:method => :post))
+          expect(list).to     have_interaction_matching(request_with(:method => :post))
         end
 
         it "delegates to the parent list when it can't find a matching interaction" do
           parent_list = mock(:has_interaction_matching? => true)
-          HTTPInteractionList.new( [], [:method], false, parent_list).should have_interaction_matching(stub)
+          expect(HTTPInteractionList.new( [], [:method], false, parent_list)).to have_interaction_matching(stub)
           parent_list = mock(:has_interaction_matching? => false)
-          HTTPInteractionList.new( [], [:method], false, parent_list).should_not have_interaction_matching(stub)
+          expect(HTTPInteractionList.new( [], [:method], false, parent_list)).not_to have_interaction_matching(stub)
         end
 
         context 'when allow_playback_repeats is set to true' do
@@ -148,9 +148,11 @@ module VCR
           it 'considers used interactions' do
             list.response_for(request_with(:method => :put))
 
-            10.times.map {
+            results = 10.times.map do
               list.has_interaction_matching?(request_with(:method => :put))
-            }.should eq([true] * 10)
+            end
+
+            expect(results).to eq([true] * 10)
           end
         end
 
@@ -160,25 +162,29 @@ module VCR
           it 'does not consider used interactions' do
             list.response_for(request_with(:method => :put))
 
-            10.times.map {
+            result = 10.times.map do
               list.has_interaction_matching?(request_with(:method => :put))
-            }.should eq([false] * 10)
+            end
+
+            expect(result).to eq([false] * 10)
           end
         end
       end
 
       describe "#response_for" do
         it 'returns nil when the list is empty' do
-          HTTPInteractionList.new([], [:method]).response_for(stub).should respond_with(nil)
+          expect(HTTPInteractionList.new([], [:method]).response_for(stub)).to respond_with(nil)
         end
 
         it 'returns nil when there is no matching interaction' do
-          HTTPInteractionList.new([
+          response = HTTPInteractionList.new([
             interaction('foo', :method => :post),
             interaction('foo', :method => :put)
           ], [:method]).response_for(
             request_with(:method => :get)
-          ).should respond_with(nil)
+          )
+
+          expect(response).to respond_with(nil)
         end
 
         it 'returns the first matching interaction' do
@@ -188,7 +194,7 @@ module VCR
             interaction('post response 2', :method => :post)
           ], [:method])
 
-          list.response_for(request_with(:method => :post)).should respond_with("post response 1")
+          expect(list.response_for(request_with(:method => :post))).to respond_with("post response 1")
         end
 
         it 'invokes each matcher block to find the matching interaction' do
@@ -202,20 +208,22 @@ module VCR
             interaction('response', :method => :put)
           ], [:foo, :bar, :baz])
 
-          list.response_for(request_with(:method => :post)).should respond_with(nil)
-          list.response_for(request_with(:method => :post)).should respond_with('response')
+          expect(list.response_for(request_with(:method => :post))).to respond_with(nil)
+          expect(list.response_for(request_with(:method => :post))).to respond_with('response')
         end
 
         it "delegates to the parent list when it can't find a matching interaction" do
           parent_list = mock(:response_for => response('parent'))
-          HTTPInteractionList.new(
+          result = HTTPInteractionList.new(
             [], [:method], false, parent_list
-          ).response_for(stub).should respond_with('parent')
+          ).response_for(stub)
+
+          expect(result).to respond_with('parent')
         end
 
         it 'consumes the first matching interaction so that it will not be used again' do
-          list.response_for(request_with(:method => :post)).body.should eq("post response 1")
-          list.response_for(request_with(:method => :post)).body.should eq("post response 2")
+          expect(list.response_for(request_with(:method => :post)).body).to eq("post response 1")
+          expect(list.response_for(request_with(:method => :post)).body).to eq("post response 2")
         end
 
         context 'when allow_playback_repeats is set to true' do
@@ -224,10 +232,12 @@ module VCR
           it 'continues to return the response from the last matching interaction when there are no more' do
             list.response_for(request_with(:method => :post))
 
-            10.times.map {
+            results = 10.times.map do
               response = list.response_for(request_with(:method => :post))
               response ? response.body : nil
-            }.should eq(["post response 2"] * 10)
+            end
+
+            expect(results).to eq(["post response 2"] * 10)
           end
         end
 
@@ -238,16 +248,18 @@ module VCR
             list.response_for(request_with(:method => :post))
             list.response_for(request_with(:method => :post))
 
-            10.times.map {
+            results = 10.times.map do
               list.response_for(request_with(:method => :post))
-            }.should eq([nil] * 10)
+            end
+
+            expect(results).to eq([nil] * 10)
           end
         end
 
         it 'does not modify the original interaction array the list was initialized with' do
           original_dup = original_list_array.dup
           list.response_for(request_with(:method => :post))
-          original_list_array.should == original_dup
+          expect(original_list_array).to eq original_dup
         end
       end
     end

data/spec/vcr/cassette/migrator_spec.rb

@@ -136,36 +136,36 @@ EOF
   it 'migrates a cassette from the 1.x to 2.x format' do
     File.open(file_name, 'w') { |f| f.write(original_contents) }
     subject.migrate!
-    YAML.load_file(file_name).should eq(YAML.load(updated_contents))
-    output.should match(/Migrated example.yml/)
+    expect(YAML.load_file(file_name)).to eq(YAML.load(updated_contents))
+    expect(output).to match(/Migrated example.yml/)
   end
 
   it 'ignores files that do not contain arrays' do
     File.open(file_name, 'w') { |f| f.write(true.to_yaml) }
     subject.migrate!
-    File.read(file_name).should eq(true.to_yaml)
-    output.should match(/Ignored example.yml since it does not appear to be a valid VCR 1.x cassette/)
+    expect(File.read(file_name)).to eq(true.to_yaml)
+    expect(output).to match(/Ignored example.yml since it does not appear to be a valid VCR 1.x cassette/)
   end
 
   it 'ignores files that contain YAML arrays of other things' do
     File.open(file_name, 'w') { |f| f.write([{}, {}].to_yaml) }
     subject.migrate!
-    File.read(file_name).should eq([{}, {}].to_yaml)
-    output.should match(/Ignored example.yml since it does not appear to be a valid VCR 1.x cassette/)
+    expect(File.read(file_name)).to eq([{}, {}].to_yaml)
+    expect(output).to match(/Ignored example.yml since it does not appear to be a valid VCR 1.x cassette/)
   end
 
   it 'ignores URIs that have sensitive data substitutions' do
     modified_contents = original_contents.gsub('example.com', '<HOST>')
     File.open(file_name, 'w') { |f| f.write(modified_contents) }
     subject.migrate!
-    YAML.load_file(file_name).should eq(YAML.load(updated_contents.gsub('example.com', '<HOST>:80')))
+    expect(YAML.load_file(file_name)).to eq(YAML.load(updated_contents.gsub('example.com', '<HOST>:80')))
   end
 
   it 'ignores files that are empty' do
     File.open(file_name, 'w') { |f| f.write('') }
     subject.migrate!
-    File.read(file_name).should eq('')
-    output.should match(/Ignored example.yml since it could not be parsed as YAML/)
+    expect(File.read(file_name)).to eq('')
+    expect(output).to match(/Ignored example.yml since it could not be parsed as YAML/)
   end
 
   shared_examples_for "ignoring invalid YAML" do
@@ -174,8 +174,8 @@ EOF
       modified_contents = modified_contents.gsub(/\z/, "<% end %>")
       File.open(file_name, 'w') { |f| f.write(modified_contents) }
       subject.migrate!
-      File.read(file_name).should eq(modified_contents)
-      output.should match(/Ignored example.yml since it could not be parsed as YAML/)
+      expect(File.read(file_name)).to eq(modified_contents)
+      expect(output).to match(/Ignored example.yml since it could not be parsed as YAML/)
     end
   end
 

data/spec/vcr/cassette/persisters/file_system_spec.rb

@@ -10,51 +10,51 @@ module VCR
         describe "#[]" do
           it 'reads from the given file, relative to the configured storage location' do
             File.open(FileSystem.storage_location + '/foo.txt', 'w') { |f| f.write('1234') }
-            FileSystem["foo.txt"].should eq("1234")
+            expect(FileSystem["foo.txt"]).to eq("1234")
           end
 
           it 'handles directories in the given file name' do
             FileUtils.mkdir_p FileSystem.storage_location + '/a'
             File.open(FileSystem.storage_location + '/a/b', 'w') { |f| f.write('1234') }
-            FileSystem["a/b"].should eq("1234")
+            expect(FileSystem["a/b"]).to eq("1234")
           end
 
           it 'returns nil if the file does not exist' do
-            FileSystem["non_existant_file"].should be_nil
+            expect(FileSystem["non_existant_file"]).to be_nil
           end
         end
 
         describe "#[]=" do
           it 'writes the given file contents to the given file name' do
-            File.exist?(FileSystem.storage_location + '/foo.txt').should be_false
+            expect(File.exist?(FileSystem.storage_location + '/foo.txt')).to be_false
             FileSystem["foo.txt"] = "bar"
-            File.read(FileSystem.storage_location + '/foo.txt').should eq("bar")
+            expect(File.read(FileSystem.storage_location + '/foo.txt')).to eq("bar")
           end
 
           it 'creates any needed intermediary directories' do
-            File.exist?(FileSystem.storage_location + '/a').should be_false
+            expect(File.exist?(FileSystem.storage_location + '/a')).to be_false
             FileSystem["a/b"] = "bar"
-            File.read(FileSystem.storage_location + '/a/b').should eq("bar")
+            expect(File.read(FileSystem.storage_location + '/a/b')).to eq("bar")
           end
         end
 
         describe "#absolute_path_to_file" do
           it "returns the absolute path to the given relative file based on the storage location" do
             expected = File.join(FileSystem.storage_location, "bar/bazz.json")
-            FileSystem.absolute_path_to_file("bar/bazz.json").should eq(expected)
+            expect(FileSystem.absolute_path_to_file("bar/bazz.json")).to eq(expected)
           end
 
           it "returns nil if the storage_location is not set" do
             FileSystem.storage_location = nil
-            FileSystem.absolute_path_to_file("bar/bazz.json").should be_nil
+            expect(FileSystem.absolute_path_to_file("bar/bazz.json")).to be_nil
           end
 
           it "sanitizes the file name" do
             expected = File.join(FileSystem.storage_location, "_t_i-t_1_2_f_n.json")
-            FileSystem.absolute_path_to_file("\nt \t!  i-t_1.2_f n.json").should eq(expected)
+            expect(FileSystem.absolute_path_to_file("\nt \t!  i-t_1.2_f n.json")).to eq(expected)
 
             expected = File.join(FileSystem.storage_location, "a_1/b")
-            FileSystem.absolute_path_to_file("a 1/b").should eq(expected)
+            expect(FileSystem.absolute_path_to_file("a 1/b")).to eq(expected)
           end
         end
       end

data/spec/vcr/cassette/persisters_spec.rb

@@ -12,7 +12,7 @@ module VCR
 
           it 'overrides the existing persister' do
             subject[:foo] = :new_persister
-            subject[:foo].should be(:new_persister)
+            expect(subject[:foo]).to be(:new_persister)
           end
 
           it 'warns that there is a name collision' do
@@ -30,7 +30,7 @@ module VCR
         end
 
         it 'returns the named persister' do
-          subject[:file_system].should be(VCR::Cassette::Persisters::FileSystem)
+          expect(subject[:file_system]).to be(VCR::Cassette::Persisters::FileSystem)
         end
       end
     end

data/spec/vcr/cassette/serializers_spec.rb

@@ -1,6 +1,7 @@
 require 'support/ruby_interpreter'
 require 'vcr/cassette/serializers'
 require 'multi_json'
+
 begin
   require 'psych' # ensure psych is loaded for these tests if its available
 rescue LoadError
@@ -26,22 +27,22 @@ module VCR
         context "the #{name} serializer" do
           it 'lazily loads the serializer' do
             serializers = subject.instance_variable_get(:@serializers)
-            serializers.should_not have_key(name)
-            subject[name].should_not be_nil
-            serializers.should have_key(name)
+            expect(serializers).not_to have_key(name)
+            expect(subject[name]).not_to be_nil
+            expect(serializers).to have_key(name)
           end if lazily_loaded
 
           it "returns '#{file_extension}' as the file extension" do
-            serializer.file_extension.should eq(file_extension)
+            expect(serializer.file_extension).to eq(file_extension)
           end
 
           it "can serialize and deserialize a hash" do
             hash = { "a" => 7, "nested" => { "hash" => [1, 2, 3] }}
             serialized = serializer.serialize(hash)
-            serialized.should_not eq(hash)
-            serialized.should be_a(String)
+            expect(serialized).not_to eq(hash)
+            expect(serialized).to be_a(String)
             deserialized = serializer.deserialize(serialized)
-            deserialized.should eq(hash)
+            expect(deserialized).to eq(hash)
           end
         end
       end
@@ -118,7 +119,7 @@ module VCR
 
           it 'overrides the existing serializer' do
             subject[:foo] = :new_serializer
-            subject[:foo].should be(:new_serializer)
+            expect(subject[:foo]).to be(:new_serializer)
           end
 
           it 'warns that there is a name collision' do
@@ -136,7 +137,7 @@ module VCR
         end
 
         it 'returns the named serializer' do
-          subject[:yaml].should be(VCR::Cassette::Serializers::YAML)
+          expect(subject[:yaml]).to be(VCR::Cassette::Serializers::YAML)
         end
       end
 
@@ -147,7 +148,7 @@ module VCR
         it 'serializes things using pysch even if syck is configured as the default YAML engine' do
           ::YAML::ENGINE.yamler = 'syck'
           serialized = subject[:psych].serialize(problematic_syck_string)
-          subject[:psych].deserialize(serialized).should eq(problematic_syck_string)
+          expect(subject[:psych].deserialize(serialized)).to eq(problematic_syck_string)
         end if defined?(::Psych)
 
         it 'raises an error if psych cannot be loaded' do
@@ -159,8 +160,8 @@ module VCR
         it 'forcibly serializes things using syck even if psych is the currently configured YAML engine' do
           ::YAML::ENGINE.yamler = 'psych'
           serialized = subject[:syck].serialize(problematic_syck_string)
-          subject[:syck].deserialize(serialized).should_not eq(problematic_syck_string)
-        end if defined?(::Psych) && (RUBY_INTERPRETER != :jruby)
+          expect(subject[:syck].deserialize(serialized)).not_to eq(problematic_syck_string)
+        end if defined?(::Psych) && (RUBY_INTERPRETER != :jruby) && (RUBY_VERSION.to_f < 2.0)
       end
     end
   end