vcr 2.0.0.beta1 → 2.0.0.beta2

data/spec/vcr/cassette/serializers_spec.rb

@@ -0,0 +1,122 @@
+require 'vcr/cassette/serializers'
+begin
+  require 'psych' # ensure psych is loaded for these tests if its available
+rescue LoadError
+end
+
+module VCR
+  class Cassette
+    describe Serializers do
+
+      shared_examples_for "a serializer" do |name, file_extension, lazily_loaded|
+        context "the #{name} serializer" do
+          let(:serializer) { subject[name] }
+
+          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)
+          end if lazily_loaded
+
+          it "returns '#{file_extension}' as the file extension" do
+            serializer.file_extension.should 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)
+            deserialized = serializer.deserialize(serialized)
+            deserialized.should eq(hash)
+          end
+        end
+      end
+
+      it_behaves_like "a serializer", :yaml,  "yml",  :lazily_loaded
+      it_behaves_like "a serializer", :syck,  "yml",  :lazily_loaded
+      it_behaves_like "a serializer", :psych, "yml",  :lazily_loaded if RUBY_VERSION =~ /1.9/
+      it_behaves_like "a serializer", :json,  "json", :lazily_loaded
+
+      context "a custom :ruby serializer" do
+        let(:custom_serializer) do
+          Object.new.tap do |obj|
+            def obj.file_extension
+              "rb"
+            end
+
+            def obj.serialize(hash)
+              hash.inspect
+            end
+
+            def obj.deserialize(string)
+              eval(string)
+            end
+          end
+        end
+
+        before(:each) do
+          subject[:ruby] = custom_serializer
+        end
+
+        it_behaves_like "a serializer", :ruby, "rb", false
+      end
+
+      describe "#[]=" do
+        context 'when there is already a serializer registered for the given name' do
+          before(:each) do
+            subject[:foo] = :old_serializer
+            subject.stub :warn
+          end
+
+          it 'overrides the existing serializer' do
+            subject[:foo] = :new_serializer
+            subject[:foo].should be(:new_serializer)
+          end
+
+          it 'warns that there is a name collision' do
+            subject.should_receive(:warn).with(
+              /WARNING: There is already a VCR cassette serializer registered for :foo\. Overriding it/
+            )
+            subject[:foo] = :new_serializer
+          end
+        end
+      end
+
+      describe "#[]" do
+        it 'raises an error when given an unrecognized serializer name' do
+          expect { subject[:foo] }.to raise_error(ArgumentError)
+        end
+
+        it 'returns the named serializer' do
+          subject[:yaml].should be(VCR::Cassette::Serializers::YAML)
+        end
+      end
+
+      # see https://gist.github.com/815769
+      problematic_syck_string = "1\n \n2"
+
+      describe "psych serializer" do
+        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)
+        end if defined?(::Psych)
+
+        it 'raises an error if psych cannot be loaded' do
+          expect { subject[:psych] }.to raise_error(LoadError)
+        end unless defined?(::Psych)
+      end
+
+      describe "syck serializer" do
+        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)
+      end
+    end
+  end
+end
+

data/spec/vcr/cassette_spec.rb

@@ -1,12 +1,25 @@
 require 'spec_helper'
 
 describe VCR::Cassette do
+  def http_interaction
+    request = VCR::Request.new(:get)
+    response = VCR::Response.new
+    response.status = VCR::ResponseStatus.new
+    VCR::HTTPInteraction.new(request, response).tap { |i| yield i if block_given? }
+  end
+
   describe '#file' do
     it 'combines the cassette_library_dir with the cassette name' do
       cassette = VCR::Cassette.new('the_file')
       cassette.file.should eq(File.join(VCR.configuration.cassette_library_dir, 'the_file.yml'))
     end
 
+    it 'uses the file extension from the serializer' do
+      VCR.cassette_serializers[:custom] = stub(:file_extension => "custom")
+      cassette = VCR::Cassette.new('the_file', :serialize_with => :custom)
+      cassette.file.should =~ /\.custom$/
+    end
+
     it 'strips out disallowed characters so that it is a valid file name with no spaces' do
       cassette = VCR::Cassette.new("\nthis \t!  is-the_13212_file name")
       cassette.file.should =~ /#{Regexp.escape('_this_is-the_13212_file_name.yml')}$/
@@ -35,6 +48,27 @@ describe VCR::Cassette do
     end
   end
 
+  describe "#serializable_hash" do
+    subject { VCR::Cassette.new("foo") }
+    let(:interactions) { [stub(:to_hash => { "i" => 1 }, :ignored? => false), stub(:to_hash => { "i" => 2 }, :ignored? => false)] }
+
+    before(:each) do
+      interactions.each do |i|
+        subject.record_http_interaction(i)
+      end
+    end
+
+    let(:metadata) { subject.serializable_hash.reject { |k,v| k == "http_interactions" } }
+
+    it 'includes the hash form of all recorded interactions' do
+      subject.serializable_hash.should include('http_interactions' => [{ "i" => 1 }, { "i" => 2 }])
+    end
+
+    it 'includes additional metadata about the cassette' do
+      metadata.should eq("recorded_with" => "VCR #{VCR.version}")
+    end
+  end
+
   describe "#recording?" do
     [:all, :new_episodes].each do |mode|
       it "returns true when the record mode is :#{mode}" do
@@ -89,57 +123,66 @@ describe VCR::Cassette do
     end
   end
 
-  describe '.new' do
-    it "raises an error if given an invalid record mode" do
-      expect { VCR::Cassette.new(:test, :record => :not_a_record_mode) }.to raise_error(ArgumentError)
+  describe "reading the file from disk" do
+    before(:each) do
+      File.stub(:size? => true)
     end
 
-    it 'raises an error if given invalid options' do
-      expect {
-        VCR::Cassette.new(:test, :invalid => :option)
-      }.to raise_error(ArgumentError)
-    end
+    let(:empty_cassette_yaml) { YAML.dump("http_interactions" => []) }
 
-    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).recorded_interactions.should eq([])
+    it 'reads the appropriate file from disk using a VCR::Cassette::Reader' do
+      VCR::Cassette::Reader.should_receive(:new).with(
+        "#{VCR.configuration.cassette_library_dir}/foo.yml", anything
+      ).and_return(mock('reader', :read => empty_cassette_yaml))
+
+      VCR::Cassette.new('foo', :record => :new_episodes).http_interactions
     end
 
-    describe "reading the file from disk" do
-      before(:each) do
-        File.stub(:size? => true)
-      end
+    [true, false, nil, { }].each do |erb|
+      it "passes #{erb.inspect} to the VCR::Cassette::Reader when given as the :erb option" do
+        # test that it overrides the default
+        VCR.configuration.default_cassette_options = { :erb => true }
 
-      it 'reads the appropriate file from disk using a VCR::Cassette::Reader' do
         VCR::Cassette::Reader.should_receive(:new).with(
-          "#{VCR.configuration.cassette_library_dir}/foo.yml", anything
-        ).and_return(mock('reader', :read => VCR::YAML.dump([])))
+          anything, erb
+        ).and_return(mock('reader', :read => empty_cassette_yaml))
 
-        VCR::Cassette.new('foo', :record => :new_episodes)
+        VCR::Cassette.new('foo', :record => :new_episodes, :erb => erb).http_interactions
       end
 
-      [true, false, nil, { }].each do |erb|
-        it "passes #{erb.inspect} to the VCR::Cassette::Reader when given as the :erb option" do
-          # test that it overrides the default
-          VCR.configuration.default_cassette_options = { :erb => true }
+      it "passes #{erb.inspect} to the VCR::Cassette::Reader when it is the default :erb option and none is given" do
+        VCR.configuration.default_cassette_options = { :erb => erb }
 
-          VCR::Cassette::Reader.should_receive(:new).with(
-            anything, erb
-          ).and_return(mock('reader', :read => VCR::YAML.dump([])))
+        VCR::Cassette::Reader.should_receive(:new).with(
+          anything, erb
+        ).and_return(mock('reader', :read => empty_cassette_yaml))
 
-          VCR::Cassette.new('foo', :record => :new_episodes, :erb => erb)
-        end
+        VCR::Cassette.new('foo', :record => :new_episodes).http_interactions
+      end
+    end
 
-        it "passes #{erb.inspect} to the VCR::Cassette::Reader when it is the default :erb option and none is given" do
-          VCR.configuration.default_cassette_options = { :erb => erb }
+    it 'raises a friendly error when the cassette file is in the old VCR 1.x format' do
+      VCR.configuration.cassette_library_dir = 'spec/fixtures/cassette_spec'
+      expect {
+        VCR::Cassette.new('1_x_cassette').http_interactions
+      }.to raise_error(VCR::Errors::InvalidCassetteFormatError)
+    end
+  end
 
-          VCR::Cassette::Reader.should_receive(:new).with(
-            anything, erb
-          ).and_return(mock('reader', :read => VCR::YAML.dump([])))
+  describe '.new' do
+    it "raises an error if given an invalid record mode" do
+      expect { VCR::Cassette.new(:test, :record => :not_a_record_mode) }.to raise_error(ArgumentError)
+    end
 
-          VCR::Cassette.new('foo', :record => :new_episodes)
-        end
-      end
+    it 'raises an error if given invalid options' do
+      expect {
+        VCR::Cassette.new(:test, :invalid => :option)
+      }.to raise_error(ArgumentError)
+    end
+
+    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).previously_recorded_interactions.should eq([])
     end
 
     VCR::Cassette::VALID_RECORD_MODES.each do |record_mode|
@@ -155,27 +198,35 @@ 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) { VCR::HTTPInteraction.new(VCR::Request.new(:get, 'http://example.com/'), VCR::Response.new(VCR::ResponseStatus.new)) }
-          let(:interaction_2) { VCR::HTTPInteraction.new(VCR::Request.new(:get, 'http://example.com/'), VCR::Response.new(VCR::ResponseStatus.new)) }
+          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
-            VCR::YAML.stub(:load => interactions)
+            stub_old_interactions(interactions)
             interaction_1.response.should_receive(:update_content_length_header)
             interaction_2.response.should_receive(:update_content_length_header)
 
-            VCR::Cassette.new('example', :record => record_mode, :update_content_length_header => true)
+            VCR::Cassette.new('example', :record => record_mode, :update_content_length_header => true).http_interactions
           end
 
           [nil, false].each do |val|
             it "does not update the content_lenth headers when given :update_content_length_header => #{val.inspect}" do
-              VCR::YAML.stub(:load => interactions)
+              stub_old_interactions(interactions)
               interaction_1.response.should_not_receive(:update_content_length_header)
               interaction_2.response.should_not_receive(:update_content_length_header)
 
-              VCR::Cassette.new('example', :record => record_mode, :update_content_length_header => val)
+              VCR::Cassette.new('example', :record => record_mode, :update_content_length_header => val).http_interactions
             end
           end
 
@@ -193,20 +244,34 @@ describe VCR::Cassette do
 
             context 'when the cassette file does exist' do
               before(:each) do
+                interactions = timestamps.map do |ts|
+                  http_interaction { |i| i.recorded_at = ts }.to_hash
+                end
+                yaml = YAML.dump("http_interactions" => interactions)
+
                 File.stub(:exist?).with(file_name).and_return(true)
-                File.stub(:read).with(file_name).and_return(VCR::YAML.dump([]))
+                File.stub(:size?).with(file_name).and_return(true)
+                File.stub(:read).with(file_name).and_return(yaml)
               end
 
-              context 'and the file was last modified less than 7 days ago' do
-                before(:each) { File.stub(:stat).with(file_name).and_return(stub(:mtime => Time.now - 7.days + 60)) }
+              context 'and the earliest recorded interaction was recorded less than 7 days ago' do
+                let(:timestamps) do [
+                  Time.now - 6.days + 60,
+                  Time.now - 7.days + 60,
+                  Time.now - 5.days + 60
+                ] end
 
                 it "has :#{record_mode} for the record mode" do
                   subject.record_mode.should eq(record_mode)
                 end
               end
 
-              context 'and the file was last modified more than 7 days ago' do
-                before(:each) { File.stub(:stat).with(file_name).and_return(stub(:mtime => Time.now - 7.days - 60)) }
+              context 'and the earliest recorded interaction was recorded more than 7 days ago' do
+                let(:timestamps) do [
+                  Time.now - 6.days - 60,
+                  Time.now - 7.days - 60,
+                  Time.now - 5.days - 60
+                ] end
 
                 it "has :all for the record mode when there is an internet connection available" do
                   VCR::InternetConnection.stub(:available? => true)
@@ -229,27 +294,27 @@ 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.recorded_interactions.map { |i| URI.parse(i.uri).host }.should eq(%w[example.com])
+          cassette.previously_recorded_interactions.map { |i| URI.parse(i.uri).host }.should 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).recorded_interactions
+          cassette.should have(3).previously_recorded_interactions
 
-          i1, i2, i3 = *cassette.recorded_interactions
+          i1, i2, i3 = *cassette.previously_recorded_interactions
 
           i1.request.method.should eq(:get)
-          i1.request.uri.should eq('http://example.com:80/')
+          i1.request.uri.should eq('http://example.com/')
           i1.response.body.should =~ /You have reached this web page by typing.+example\.com/
 
           i2.request.method.should eq(:get)
-          i2.request.uri.should eq('http://example.com:80/foo')
+          i2.request.uri.should eq('http://example.com/foo')
           i2.response.body.should =~ /foo was not found on this server/
 
           i3.request.method.should eq(:get)
-          i3.request.uri.should eq('http://example.com:80/')
+          i3.request.uri.should eq('http://example.com/')
           i3.response.body.should =~ /Another example\.com response/
         end
 
@@ -285,7 +350,7 @@ describe VCR::Cassette do
             ).exactly(3).times
 
             cassette = VCR::Cassette.new('example', :record => record_mode, :tag => :foo)
-            cassette.should have(3).recorded_interactions
+            cassette.should have(3).previously_recorded_interactions
           end
 
           it 'does not playback any interactions that are ignored in a before_playback hook' do
@@ -295,7 +360,7 @@ 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).recorded_interactions
+            cassette.should have(2).previously_recorded_interactions
           end
 
           it 'instantiates the http_interactions with the loaded interactions and the request matchers' do
@@ -317,25 +382,21 @@ describe VCR::Cassette do
   end
 
   describe '#eject' do
-    it "writes the recorded interactions to disk as yaml" do
-      recorded_interactions = [
-        VCR::HTTPInteraction.new(:req_sig_1, :response_1),
-        VCR::HTTPInteraction.new(:req_sig_2, :response_2),
-        VCR::HTTPInteraction.new(:req_sig_3, :response_3)
-      ]
-
+    it "writes the serializable_hash to disk as yaml" do
       cassette = VCR::Cassette.new(:eject_test)
-      cassette.stub!(:new_recorded_interactions).and_return(recorded_interactions)
+      cassette.record_http_interaction http_interaction # so it has one
+      cassette.should 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_recorded_interactions = VCR::YAML.load_file(cassette.file)
-      saved_recorded_interactions.should eq(recorded_interactions)
+      saved_stuff = YAML.load_file(cassette.file)
+      saved_stuff.should eq("http_interactions" => [1, 3, 5])
     end
 
     it 'invokes the appropriately tagged before_record hooks' do
       interactions = [
-        VCR::HTTPInteraction.new(:req_sig_1, :response_1),
-        VCR::HTTPInteraction.new(:req_sig_2, :response_2)
+        http_interaction { |i| i.request.uri = 'http://foo.com/'; i.response.body = 'res 1' },
+        http_interaction { |i| i.request.uri = 'http://bar.com/'; i.response.body = 'res 2' }
       ]
 
       cassette = VCR::Cassette.new('example', :tag => :foo)
@@ -354,8 +415,8 @@ describe VCR::Cassette do
     end
 
     it 'does not record interactions that have been ignored' do
-      interaction_1 = VCR::HTTPInteraction.new(:request_1, :response_1)
-      interaction_2 = VCR::HTTPInteraction.new(:request_2, :response_2)
+      interaction_1 = http_interaction { |i| i.request.uri = 'http://foo.com/'; i.response.body = 'res 1' }
+      interaction_2 = http_interaction { |i| i.request.uri = 'http://bar.com/'; i.response.body = 'res 2' }
 
       interaction_1.ignore!
 
@@ -363,12 +424,12 @@ describe VCR::Cassette do
       cassette.stub!(:new_recorded_interactions).and_return([interaction_1, interaction_2])
       cassette.eject
 
-      saved_recorded_interactions = VCR::YAML.load_file(cassette.file)
-      saved_recorded_interactions.should eq([interaction_2])
+      saved_recorded_interactions = ::YAML.load_file(cassette.file)
+      saved_recorded_interactions["http_interactions"].should eq([interaction_2.to_hash])
     end
 
     it 'does not write the cassette to disk if all interactions have been ignored' do
-      interaction_1 = VCR::HTTPInteraction.new(:request_1, :response_1)
+      interaction_1 = http_interaction { |i| i.request.uri = 'http://foo.com/'; i.response.body = 'res 1' }
       interaction_1.ignore!
 
       cassette = VCR::Cassette.new('test_cassette')
@@ -379,13 +440,13 @@ describe VCR::Cassette do
     end
 
     it "writes the recorded interactions to a subdirectory if the cassette name includes a directory" do
-      recorded_interactions = [VCR::HTTPInteraction.new(:the_request, :the_response)]
+      recorded_interactions = [http_interaction { |i| i.response.body = "subdirectory response" }]
       cassette = VCR::Cassette.new('subdirectory/test_cassette')
-      cassette.stub!(:new_recorded_interactions).and_return(recorded_interactions)
+      cassette.stub(:new_recorded_interactions => recorded_interactions)
 
       expect { cassette.eject }.to change { File.exist?(cassette.file) }.from(false).to(true)
-      saved_recorded_interactions = VCR::YAML.load_file(cassette.file)
-      saved_recorded_interactions.should eq(recorded_interactions)
+      saved_recorded_interactions = YAML.load_file(cassette.file)
+      saved_recorded_interactions["http_interactions"].should eq(recorded_interactions.map(&:to_hash))
     end
 
     [:all, :none, :new_episodes].each do |record_mode|
@@ -404,22 +465,25 @@ describe VCR::Cassette do
         end
 
         context 'when some new interactions have been recorded' do
-          def interaction(response, request_attributes)
-            request = VCR::Request.new
-            request_attributes.each do |key, value|
-              request.send("#{key}=", value)
+          def interaction(response_body, request_attributes)
+            http_interaction do |interaction|
+              interaction.response.body = response_body
+              request_attributes.each do |key, value|
+                interaction.request.send("#{key}=", value)
+              end
             end
-            VCR::HTTPInteraction.new(request, response)
           end
 
           let(:interaction_foo_1) { interaction("foo 1", :uri => 'http://foo.com/') }
           let(:interaction_foo_2) { interaction("foo 2", :uri => 'http://foo.com/') }
           let(:interaction_bar)   { interaction("bar", :uri => 'http://bar.com/') }
 
-          let(:saved_recorded_interactions) { VCR::YAML.load_file(subject.file) }
+          let(:saved_recorded_interactions) { YAML.load_file(subject.file)['http_interactions'].map { |h| VCR::HTTPInteraction.from_hash(h) } }
+          let(:now) { Time.utc(2011, 6, 11, 12, 30) }
 
           before(:each) do
-            subject.stub(:recorded_interactions => [interaction_foo_1])
+            Time.stub(:now => now)
+            subject.stub(:previously_recorded_interactions => [interaction_foo_1])
             subject.record_http_interaction(interaction_foo_2)
             subject.record_http_interaction(interaction_bar)
             subject.eject