vcr 2.0.0.rc1 → 2.0.0.rc2

data/spec/support/shared_example_groups/request_hooks.rb

@@ -1,13 +1,6 @@
-shared_examples_for "request hooks" do |library_hook_name|
+shared_examples_for "request hooks" do |library_hook_name, request_type|
   let(:request_url) { "http://localhost:#{VCR::SinatraApp.port}/foo" }
 
-  before(:each) do
-    # ensure that all the other library hooks are disabled so that we don't
-    # get double-hookage (such as for WebMock and Typhoeus both invoking the
-    # hooks for a typhoeus request)
-    VCR.library_hooks.stub(:disabled?) { |lib_name| lib_name != library_hook_name }
-  end
-
   def make_request(disabled = false)
     make_http_request(:get, request_url)
   end
@@ -45,6 +38,14 @@ shared_examples_for "request hooks" do |library_hook_name|
       make_request(:disabled)
       hook_called.should be_false
     end
+
+    specify "the #type of the yielded request given to the #{hook} hook is #{request_type}" do
+      request = nil
+      VCR.configuration.send(hook) { |r| request = r }
+
+      make_request
+      request.type.should be(request_type)
+    end
   end
 
   specify "the after_http_request hook yields the response if there is one and the second block arg is given" do

data/spec/support/sinatra_app.rb

@@ -2,6 +2,8 @@ require 'sinatra'
 
 module VCR
   class SinatraApp < ::Sinatra::Base
+    disable :protection
+
     get '/' do
       "GET to root"
     end
@@ -28,7 +30,7 @@ module VCR
     end
 
     get '/set-cookie-headers/2' do
-      headers 'Set-Cookie' => %w[ foo bar ]
+      headers 'Set-Cookie' => %w[ bar foo ]
       'header set'
     end
 

data/spec/support/vcr_localhost_server.rb

@@ -59,6 +59,7 @@ module VCR
     def concurrently
       if should_use_subprocess?
         pid = Process.fork do
+          trap(:INT) { ::Rack::Handler::WEBrick.shutdown }
           yield
           exit # manually exit; otherwise this sub-process will re-run the specs that haven't run yet.
         end

data/spec/vcr/cassette/http_interaction_list_spec.rb

@@ -1,3 +1,4 @@
+require 'vcr/util/logger'
 require 'vcr/cassette/http_interaction_list'
 require 'vcr/request_matcher_registry'
 require 'vcr/structs'
@@ -5,57 +6,14 @@ require 'uri'
 
 module VCR
   class Cassette
-
-    shared_examples_for "an HTTP interaction finding method" do |method|
-      it 'returns nil when the list is empty' do
-        HTTPInteractionList.new([], [:method]).send(method, stub).should respond_with(nil)
-      end
-
-      it 'returns nil when there is no matching interaction' do
-        HTTPInteractionList.new([
-          interaction('foo', :method => :post),
-          interaction('foo', :method => :put)
-        ], [:method]).send(method,
-          request_with(:method => :get)
-        ).should respond_with(nil)
-      end
-
-      it 'returns the first matching interaction' do
-        list = HTTPInteractionList.new([
-          interaction('put response', :method => :put),
-          interaction('post response 1', :method => :post),
-          interaction('post response 2', :method => :post)
-        ], [:method])
-
-        list.send(method, request_with(:method => :post)).should respond_with("post response 1")
-      end
-
-      it 'invokes each matcher block to find the matching interaction' do
-        VCR.request_matchers.register(:foo) { |r1, r2| true }
-        VCR.request_matchers.register(:bar) { |r1, r2| true }
-
-        calls = 0
-        VCR.request_matchers.register(:baz) { |r1, r2| calls += 1; calls == 2 }
-
-        list = HTTPInteractionList.new([
-          interaction('response', :method => :put)
-        ], [:foo, :bar, :baz])
-
-        list.send(method, request_with(:method => :post)).should respond_with(nil)
-        list.send(method, request_with(:method => :post)).should respond_with('response')
-      end
-
-      it "delegates to the parent list when it can't find a matching interaction" do
-        parent_list = mock(method => response('parent'))
-        HTTPInteractionList.new(
-          [], [:method], false, parent_list
-        ).send(method, stub).should respond_with('parent')
+    describe HTTPInteractionList do
+      ::RSpec::Matchers.define :respond_with do |expected|
+        match { |a| expected.nil? ? a.nil? : a.body == expected }
       end
-    end
 
-    describe HTTPInteractionList do
       before(:each) do
         VCR.stub(:request_matchers => VCR::RequestMatcherRegistry.new)
+        VCR.stub_chain(:configuration, :debug_logger).and_return(stub.as_null_object)
       end
 
       def request_with(values)
@@ -67,7 +25,10 @@ module VCR
       end
 
       def response(body)
-        VCR::Response.new.tap { |r| r.body = body }
+        VCR::Response.new.tap do |r|
+          r.body = body
+          r.status = VCR::ResponseStatus.new(200)
+        end
       end
 
       def interaction(body, request_values)
@@ -125,14 +86,118 @@ module VCR
         end
       end
 
-      describe "#response_for" do
-        it_behaves_like "an HTTP interaction finding method", :response_for do
-          def respond_with(value)
-            ::RSpec::Matchers::Matcher.new :respond_with, value do |expected|
-              match { |a| expected.nil? ? a.nil? : a.body == expected }
-            end
+      describe "has_interaction_matching?" do
+        it 'returns false when the list is empty' do
+          HTTPInteractionList.new([], [:method]).should_not 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))
+        end
+
+        it 'returns true when there is a matching interaction' do
+          list.should 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)
+        end
+
+        it 'invokes each matcher block to find the matching interaction' do
+          VCR.request_matchers.register(:foo) { |r1, r2| true }
+          VCR.request_matchers.register(:bar) { |r1, r2| true }
+
+          calls = 0
+          VCR.request_matchers.register(:baz) { |r1, r2| calls += 1; calls == 2 }
+
+          list = HTTPInteractionList.new([
+            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))
+        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)
+          parent_list = mock(:has_interaction_matching? => false)
+          HTTPInteractionList.new( [], [:method], false, parent_list).should_not have_interaction_matching(stub)
+        end
+
+        context 'when allow_playback_repeats is set to true' do
+          let(:allow_playback_repeats) { true }
+
+          it 'considers used interactions' do
+            list.response_for(request_with(:method => :put))
+
+            10.times.map {
+              list.has_interaction_matching?(request_with(:method => :put))
+            }.should eq([true] * 10)
+          end
+        end
+
+        context 'when allow_playback_repeats is set to false' do
+          let(:allow_playback_repeats) { false }
+
+          it 'does not consider used interactions' do
+            list.response_for(request_with(:method => :put))
+
+            10.times.map {
+              list.has_interaction_matching?(request_with(:method => :put))
+            }.should 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)
+        end
+
+        it 'returns nil when there is no matching interaction' do
+          HTTPInteractionList.new([
+            interaction('foo', :method => :post),
+            interaction('foo', :method => :put)
+          ], [:method]).response_for(
+            request_with(:method => :get)
+          ).should respond_with(nil)
+        end
+
+        it 'returns the first matching interaction' do
+          list = HTTPInteractionList.new([
+            interaction('put response', :method => :put),
+            interaction('post response 1', :method => :post),
+            interaction('post response 2', :method => :post)
+          ], [:method])
+
+          list.response_for(request_with(:method => :post)).should respond_with("post response 1")
+        end
+
+        it 'invokes each matcher block to find the matching interaction' do
+          VCR.request_matchers.register(:foo) { |r1, r2| true }
+          VCR.request_matchers.register(:bar) { |r1, r2| true }
+
+          calls = 0
+          VCR.request_matchers.register(:baz) { |r1, r2| calls += 1; calls == 2 }
+
+          list = HTTPInteractionList.new([
+            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')
+        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(
+            [], [:method], false, parent_list
+          ).response_for(stub).should 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")

data/spec/vcr/cassette/migrator_spec.rb

@@ -47,7 +47,9 @@ http_interactions:
 - request: 
     method: get
     uri: http://example.com/foo
-    body: ""
+    body:
+      encoding: US-ASCII
+      string: ""
     headers: {}
 
   response: 
@@ -59,13 +61,17 @@ http_interactions:
       - text/html;charset=utf-8
       Content-Length: 
       - "9"
-    body: Hello foo
+    body:
+      encoding: UTF-8
+      string: Hello foo
     http_version: "1.1"
   recorded_at: Wed, 04 May 2011 12:30:00 GMT
 - request: 
     method: get
     uri: http://localhost:7777/bar
-    body: ""
+    body:
+      encoding: US-ASCII
+      string: ""
     headers: {}
 
   response: 
@@ -77,7 +83,9 @@ http_interactions:
       - text/html;charset=utf-8
       Content-Length: 
       - "9"
-    body: Hello bar
+    body:
+      encoding: UTF-8
+      string: Hello bar
     http_version: "1.1"
   recorded_at: Wed, 04 May 2011 12:30:00 GMT
 recorded_with: VCR #{VCR.version}
@@ -92,6 +100,11 @@ EOF
     FileUtils.mkdir_p dir
   end
 
+  before(:each) do
+    # the encoding won't be set on rubies that don't support it
+    updated_contents.gsub!(/^\s+encoding:.*$/, '')
+  end unless ''.respond_to?(:encoding)
+
   # JRuby serializes YAML with some slightly different whitespace.
   before(:each) do
     [original_contents, updated_contents].each do |contents|
@@ -123,7 +136,7 @@ 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!
-    File.read(file_name).should eq(updated_contents)
+    YAML.load_file(file_name).should eq(YAML.load(updated_contents))
     output.should match(/Migrated example.yml/)
   end
 
@@ -145,7 +158,7 @@ EOF
     modified_contents = original_contents.gsub('example.com', '<HOST>')
     File.open(file_name, 'w') { |f| f.write(modified_contents) }
     subject.migrate!
-    File.read(file_name).should eq(updated_contents.gsub('example.com', '<HOST>:80'))
+    YAML.load_file(file_name).should eq(YAML.load(updated_contents.gsub('example.com', '<HOST>:80')))
   end
 
   it 'ignores files that are empty' do

data/spec/vcr/cassette/serializers_spec.rb

@@ -1,4 +1,5 @@
 require 'vcr/cassette/serializers'
+require 'multi_json'
 begin
   require 'psych' # ensure psych is loaded for these tests if its available
 rescue LoadError
@@ -7,11 +8,21 @@ end
 module VCR
   class Cassette
     describe Serializers do
+      shared_examples_for "encoding error handling" do |name, error_class|
+        context "the #{name} serializer" do
+          it 'appends info about the :preserve_exact_body_bytes option to the error' do
+            expect {
+              result = serializer.serialize("a" => string)
+              serializer.deserialize(result)
+            }.to raise_error(error_class, /preserve_exact_body_bytes/)
+          end
+        end
+      end
 
       shared_examples_for "a serializer" do |name, file_extension, lazily_loaded|
-        context "the #{name} serializer" do
-          let(:serializer) { subject[name] }
+        let(:serializer) { subject[name] }
 
+        context "the #{name} serializer" do
           it 'lazily loads the serializer' do
             serializers = subject.instance_variable_get(:@serializers)
             serializers.should_not have_key(name)
@@ -34,10 +45,44 @@ module VCR
         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
+      it_behaves_like "a serializer", :yaml,  "yml",  :lazily_loaded do
+        it_behaves_like "encoding error handling", :yaml, ArgumentError do
+          let(:string) { "\xFA".force_encoding("UTF-8") }
+          before { ::YAML::ENGINE.yamler = 'psych' }
+        end if ''.respond_to?(:encoding)
+      end
+
+      it_behaves_like "a serializer", :syck,  "yml",  :lazily_loaded do
+        it_behaves_like "encoding error handling", :syck, ArgumentError do
+          let(:string) { "\xFA".force_encoding("UTF-8") }
+        end if ''.respond_to?(:encoding)
+      end
+
+      it_behaves_like "a serializer", :psych, "yml",  :lazily_loaded do
+        it_behaves_like "encoding error handling", :psych, ArgumentError do
+          let(:string) { "\xFA".force_encoding("UTF-8") }
+        end if ''.respond_to?(:encoding)
+      end if RUBY_VERSION =~ /1.9/
+
+      it_behaves_like "a serializer", :json,  "json", :lazily_loaded do
+        engines = {}
+
+        engines[:yajl] = ::MultiJson::DecodeError unless RUBY_INTERPRETER == :jruby
+
+        if RUBY_VERSION =~ /1.9/
+          engines[:json_gem] = EncodingError
+          engines[:json_pure] = EncodingError
+        end
+
+        engines.each do |engine, error|
+          context "when MultiJson is configured to use #{engine.inspect}" do
+            before { MultiJson.engine = engine }
+            it_behaves_like "encoding error handling", :json, error do
+              let(:string) { "\xFA" }
+            end
+          end
+        end
+      end
 
       context "a custom :ruby serializer" do
         let(:custom_serializer) do

data/spec/vcr/cassette_spec.rb

@@ -39,18 +39,36 @@ describe VCR::Cassette do
     end
   end
 
+  describe '#tags' do
+    it 'returns a blank array if no tag has been set' do
+      VCR::Cassette.new("name").tags.should eq([])
+    end
+
+    it 'converts a single :tag to an array' do
+      VCR::Cassette.new("name", :tag => :foo).tags.should eq([:foo])
+    end
+
+    it 'accepts an array as the :tags option' do
+      VCR::Cassette.new("name", :tags => [:foo]).tags.should eq([:foo])
+    end
+  end
+
   describe '#record_http_interaction' do
+    let(:the_interaction) { stub(:request => stub(:method => :get).as_null_object).as_null_object }
+
     it 'adds the interaction to #new_recorded_interactions' do
       cassette = VCR::Cassette.new(:test_cassette)
       cassette.new_recorded_interactions.should eq([])
-      cassette.record_http_interaction(:the_interaction)
-      cassette.new_recorded_interactions.should eq([:the_interaction])
+      cassette.record_http_interaction(the_interaction)
+      cassette.new_recorded_interactions.should eq([the_interaction])
     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)] }
+    let(:interaction_1) { http_interaction { |i| i.request.body = 'req body 1'; i.response.body = 'res body 1' } }
+    let(:interaction_2) { http_interaction { |i| i.request.body = 'req body 2'; i.response.body = 'res body 2' } }
+    let(:interactions)  { [interaction_1, interaction_2] }
 
     before(:each) do
       interactions.each do |i|
@@ -61,7 +79,9 @@ describe VCR::Cassette do
     let(:metadata) { subject.serializable_hash.reject { |k,v| k == "http_interactions" } }
 
     it 'includes the hash form of all recorded interactions' do
-      subject.serializable_hash.should include('http_interactions' => [{ "i" => 1 }, { "i" => 2 }])
+      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' => '' }])
     end
 
     it 'includes additional metadata about the cassette' do
@@ -182,7 +202,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).previously_recorded_interactions.should eq([])
+      VCR::Cassette.new('empty', :record => :none).send(:previously_recorded_interactions).should eq([])
     end
 
     VCR::Cassette::VALID_RECORD_MODES.each do |record_mode|
@@ -294,7 +314,7 @@ 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.previously_recorded_interactions.map { |i| URI.parse(i.uri).host }.should eq(%w[example.com])
+          cassette.send(:previously_recorded_interactions).map { |i| URI.parse(i.request.uri).host }.should eq(%w[example.com])
         end
 
         it "loads the recorded interactions from the library yml file" do
@@ -303,7 +323,7 @@ describe VCR::Cassette do
 
           cassette.should have(3).previously_recorded_interactions
 
-          i1, i2, i3 = *cassette.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/')
@@ -341,15 +361,14 @@ describe VCR::Cassette do
         end
 
         if stub_requests
-          it 'invokes the appropriately tagged before_playback hooks' do
-            VCR.configuration.should_receive(:invoke_tagged_hook).with(
+          it 'invokes the before_playback hooks' do
+            VCR.configuration.should_receive(:invoke_hook).with(
               :before_playback,
-              :foo,
-              an_instance_of(VCR::HTTPInteraction),
+              an_instance_of(VCR::HTTPInteraction::HookAware),
               an_instance_of(VCR::Cassette)
             ).exactly(3).times
 
-            cassette = VCR::Cassette.new('example', :record => record_mode, :tag => :foo)
+            cassette = VCR::Cassette.new('example', :record => record_mode)
             cassette.should have(3).previously_recorded_interactions
           end
 
@@ -367,14 +386,14 @@ describe VCR::Cassette 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].map { |m| VCR.request_matchers[m] })
+            cassette.http_interactions.request_matchers.should 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].map { |m| VCR.request_matchers[m] })
+            cassette.http_interactions.request_matchers.should eq([:body, :headers])
           end
         end
       end
@@ -402,11 +421,12 @@ describe VCR::Cassette do
       cassette = VCR::Cassette.new('example', :tag => :foo)
       cassette.stub!(:new_recorded_interactions).and_return(interactions)
 
+      VCR.configuration.stub(:invoke_hook).and_return([false])
+
       interactions.each do |i|
-        VCR.configuration.should_receive(:invoke_tagged_hook).with(
+        VCR.configuration.should_receive(:invoke_hook).with(
           :before_record,
-          :foo,
-          i,
+          an_instance_of(VCR::HTTPInteraction::HookAware),
           cassette
         ).ordered
       end
@@ -418,7 +438,9 @@ describe VCR::Cassette do
       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!
+      hook_aware_interaction_1 = interaction_1.hook_aware
+      interaction_1.stub(:hook_aware => hook_aware_interaction_1)
+      hook_aware_interaction_1.ignore!
 
       cassette = VCR::Cassette.new('test_cassette')
       cassette.stub!(:new_recorded_interactions).and_return([interaction_1, interaction_2])
@@ -430,7 +452,10 @@ describe VCR::Cassette do
 
     it 'does not write the cassette to disk if all interactions have been ignored' do
       interaction_1 = http_interaction { |i| i.request.uri = 'http://foo.com/'; i.response.body = 'res 1' }
-      interaction_1.ignore!
+
+      hook_aware_interaction_1 = interaction_1.hook_aware
+      interaction_1.stub(:hook_aware => hook_aware_interaction_1)
+      hook_aware_interaction_1.ignore!
 
       cassette = VCR::Cassette.new('test_cassette')
       cassette.stub!(:new_recorded_interactions).and_return([interaction_1])