vcr 2.0.0.beta2 → 2.0.0.rc1

data/spec/vcr/cassette/http_interaction_list_spec.rb

@@ -85,44 +85,43 @@ module VCR
       let(:allow_playback_repeats) { false } # the default
       let(:list) { HTTPInteractionList.new(original_list_array, [:method], allow_playback_repeats) }
 
-      describe "#has_interaction_matching?" do
-        it_behaves_like "an HTTP interaction finding method", :has_interaction_matching? do
-          def respond_with(value)
-            ::RSpec::Matchers::Matcher.new :respond_with, value do |expected|
-              match { |a| expected ? a : !a }
-            end
-          end
+      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))
         end
 
-        it 'does not consume the first matching interaction' do
-          10.times do
-            list.has_interaction_matching?(request_with(:method => :post)).should be_true
-          end
-          list.response_for(request_with(:method => :post)).body.should eq("post response 1")
+        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))
         end
 
-        context 'when allow_playback_repeats is set to false' do
-          let(:allow_playback_repeats) { false }
+        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))
+        end
+      end
 
-          it 'returns false when there is a used (but no unused) matching interactions' do
-            list.response_for(request_with(:method => :put))
+      describe "#remaining_unused_interaction_count" do
+        it 'returns the number of unused interactions' do
+          list.remaining_unused_interaction_count.should eq(3)
 
-            10.times.map {
-              list.has_interaction_matching?(request_with(:method => :put))
-            }.should eq([false] * 10)
-          end
-        end
+          list.response_for(request_with(:method => :get))
+          list.remaining_unused_interaction_count.should eq(3)
 
-        context 'when allow_playback_repeats is set to true' do
-          let(:allow_playback_repeats) { true }
+          list.response_for(request_with(:method => :put))
+          list.remaining_unused_interaction_count.should eq(2)
 
-          it 'returns true when there is a used (but no unused) matching interactions' do
-            list.response_for(request_with(:method => :put))
+          list.response_for(request_with(:method => :put))
+          list.remaining_unused_interaction_count.should eq(2)
 
-            10.times.map {
-              list.has_interaction_matching?(request_with(:method => :put))
-            }.should eq([true] * 10)
-          end
+          list.response_for(request_with(:method => :post))
+          list.remaining_unused_interaction_count.should eq(1)
+
+          list.response_for(request_with(:method => :post))
+          list.remaining_unused_interaction_count.should eq(0)
+
+          list.response_for(request_with(:method => :post))
+          list.remaining_unused_interaction_count.should eq(0)
         end
       end
 

data/spec/vcr/cassette/migrator_spec.rb

@@ -80,17 +80,16 @@ http_interactions:
     body: Hello bar
     http_version: "1.1"
   recorded_at: Wed, 04 May 2011 12:30:00 GMT
-recorded_with: VCR 1.11.3
+recorded_with: VCR #{VCR.version}
 EOF
   }
 
-  attr_accessor :dir
+  let(:dir) { './tmp/migrator' }
 
-  around(:each) do |example|
-    Dir.mktmpdir do |dir|
-      self.dir = dir
-      example.run
-    end
+  before(:each) do
+    # ensure the directory is empty
+    FileUtils.rm_rf dir
+    FileUtils.mkdir_p dir
   end
 
   # JRuby serializes YAML with some slightly different whitespace.

data/spec/vcr/cassette_spec.rb

@@ -330,7 +330,7 @@ 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_a(VCR::Cassette::HTTPInteractionList::NullList)
+          cassette.http_interactions.parent_list.should be(VCR::Cassette::HTTPInteractionList::NullList)
         end
 
         it "instantiates the http_interactions with parent_list set to VCR.http_interactions if given :exclusive => false" do
@@ -342,7 +342,7 @@ describe VCR::Cassette do
 
         if stub_requests
           it 'invokes the appropriately tagged before_playback hooks' do
-            VCR.configuration.should_receive(:invoke_hook).with(
+            VCR.configuration.should_receive(:invoke_tagged_hook).with(
               :before_playback,
               :foo,
               an_instance_of(VCR::HTTPInteraction),
@@ -367,14 +367,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 == [:body, :headers]
+            cassette.http_interactions.request_matchers.should eq([:body, :headers].map { |m| VCR.request_matchers[m] })
           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 == [:body, :headers]
+            cassette.http_interactions.request_matchers.should eq([:body, :headers].map { |m| VCR.request_matchers[m] })
           end
         end
       end
@@ -403,7 +403,7 @@ describe VCR::Cassette do
       cassette.stub!(:new_recorded_interactions).and_return(interactions)
 
       interactions.each do |i|
-        VCR.configuration.should_receive(:invoke_hook).with(
+        VCR.configuration.should_receive(:invoke_tagged_hook).with(
           :before_record,
           :foo,
           i,

data/spec/vcr/configuration_spec.rb

@@ -92,6 +92,15 @@ describe VCR::Configuration do
     end
   end
 
+  describe '#ignore_request' do
+    it 'registers the given block with the request ignorer' do
+      block_called = false
+      subject.ignore_request { |r| block_called = true }
+      VCR.request_ignorer.ignore?(stub(:uri => 'http://foo.com/'))
+      block_called.should be_true
+    end
+  end
+
   describe '#allow_http_connections_when_no_cassette=' do
     [true, false].each do |val|
       it "sets the allow_http_connections_when_no_cassette to #{val} when set to #{val}" do
@@ -101,47 +110,57 @@ describe VCR::Configuration do
     end
   end
 
-  describe '#filter_sensitive_data' do
-    let(:interaction) { mock('interaction') }
-    before(:each) { interaction.stub(:filter!) }
+  %w[ filter_sensitive_data define_cassette_placeholder ].each do |method|
+    describe "##{method}" do
+      let(:interaction) { mock('interaction') }
+      before(:each) { interaction.stub(:filter!) }
 
-    it 'adds a before_record hook that replaces the string returned by the block with the given string' do
-      subject.filter_sensitive_data('foo', &lambda { 'bar' })
-      interaction.should_receive(:filter!).with('bar', 'foo')
-      subject.invoke_hook(:before_record, nil, interaction)
-    end
+      it 'adds a before_record hook that replaces the string returned by the block with the given string' do
+        subject.send(method, 'foo', &lambda { 'bar' })
+        interaction.should_receive(:filter!).with('bar', 'foo')
+        subject.invoke_hook(:before_record, interaction)
+      end
 
-    it 'adds a before_playback hook that replaces the given string with the string returned by the block' do
-      subject.filter_sensitive_data('foo', &lambda { 'bar' })
-      interaction.should_receive(:filter!).with('foo', 'bar')
-      subject.invoke_hook(:before_playback, nil, interaction)
-    end
+      it 'adds a before_playback hook that replaces the given string with the string returned by the block' do
+        subject.send(method, 'foo', &lambda { 'bar' })
+        interaction.should_receive(:filter!).with('foo', 'bar')
+        subject.invoke_hook(:before_playback, interaction)
+      end
 
-    it 'tags the before_record hook when given a tag' do
-      subject.should_receive(:before_record).with(:my_tag)
-      subject.filter_sensitive_data('foo', :my_tag) { 'bar' }
-    end
+      it 'tags the before_record hook when given a tag' do
+        subject.should_receive(:before_record).with(:my_tag)
+        subject.send(method, 'foo', :my_tag) { 'bar' }
+      end
 
-    it 'tags the before_playback hook when given a tag' do
-      subject.should_receive(:before_playback).with(:my_tag)
-      subject.filter_sensitive_data('foo', :my_tag) { 'bar' }
-    end
+      it 'tags the before_playback hook when given a tag' do
+        subject.should_receive(:before_playback).with(:my_tag)
+        subject.send(method, 'foo', :my_tag) { 'bar' }
+      end
 
-    it 'yields the interaction to the block for the before_record hook' do
-      yielded_interaction = nil
-      subject.filter_sensitive_data('foo', &lambda { |i| yielded_interaction = i; 'bar' })
-      subject.invoke_hook(:before_record, nil, interaction)
-      yielded_interaction.should equal(interaction)
-    end
+      it 'yields the interaction to the block for the before_record hook' do
+        yielded_interaction = nil
+        subject.send(method, 'foo', &lambda { |i| yielded_interaction = i; 'bar' })
+        subject.invoke_hook(:before_record, interaction)
+        yielded_interaction.should equal(interaction)
+      end
 
-    it 'yields the interaction to the block for the before_playback hook' do
-      yielded_interaction = nil
-      subject.filter_sensitive_data('foo', &lambda { |i| yielded_interaction = i; 'bar' })
-      subject.invoke_hook(:before_playback, nil, interaction)
-      yielded_interaction.should equal(interaction)
+      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)
+        yielded_interaction.should equal(interaction)
+      end
     end
   end
 
+  describe "#around_http_request, when called on ruby 1.8" do
+    it 'raises an error since fibers are not available' do
+      expect {
+        subject.around_http_request { }
+      }.to raise_error(/requires fibers, which are not available/)
+    end
+  end if RUBY_VERSION < '1.9'
+
   describe "#cassette_serializers" do
     let(:custom_serializer) { stub }
     it 'allows a custom serializer to be registered' do

data/spec/vcr/deprecations_spec.rb

@@ -73,14 +73,6 @@ describe VCR, 'deprecations', :disable_warnings do
     end
   end
 
-  describe "VCR.configure { |c| c.stub_with :faraday }" do
-    it 'prints a descriptive warning' do
-      Kernel.should_receive(:warn).with(/Just use `VCR::Middleware::Faraday` in your faraday stack/)
-      # simulate the loading of the adapter (since it may have already been required)
-      load 'vcr/library_hooks/faraday.rb'
-    end
-  end
-
   describe "VCR::Middleware::Faraday" do
     it 'prints a deprecation warning when passed a block' do
       Kernel.should_receive(:warn).with(/Passing a block .* is deprecated/)

data/spec/vcr/errors_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+module VCR
+  module Errors
+    describe UnhandledHTTPRequestError do
+      def message_for(request_values = {})
+        described_class.new(request_with request_values).message
+      end
+      alias message message_for
+
+      def request_with(values)
+        VCR::Request.new.tap do |request|
+          values.each do |name, value|
+            request.send("#{name}=", value)
+          end
+        end
+      end
+
+      it 'identifies the request by method and URI' do
+        message_for(:method => :post, :uri => 'http://foo.com/').should include(
+          'POST http://foo.com/'
+        )
+      end
+
+      context 'when there is no current cassette' do
+        it 'mentions that there is no current cassette' do
+          message.should include('There is currently no cassette in use.')
+        end
+
+        it 'mentions that the request can be recorded by inserting a cassette' do
+          message.should match(/record this request and play it back.*VCR.use_cassette/m)
+        end
+
+        it 'mentions the allow_http_connections_when_no_cassette option' do
+          message.should include('allow_http_connections_when_no_cassette')
+        end
+
+        it 'mentions that the request can be ignored' do
+          message.should include('set an `ignore_request` callback')
+        end
+
+        it 'does not double-insert the asterisks for the bullet points' do
+          message.should_not match(/\s+\*\s+\*/)
+        end
+      end
+
+      context 'when there is a current cassette' do
+        it 'mentions the details about the current casette' do
+          VCR.use_cassette('example') do
+            message.should match(/VCR is currently using the following cassette:.+example.yml/m)
+          end
+        end
+
+        it 'mentions that :new_episodes can be used to record the request' do
+          VCR.use_cassette('example') do
+            message.should include('use the :new_episodes record mode')
+          end
+        end
+
+        it 'mentions that :once does not allow a cassette to be re-recorded' do
+          VCR.use_cassette('example', :record => :once) do
+            message.should include('(:once) does not allow new requests to be recorded')
+          end
+        end
+
+        it 'mentions that :none does not allow any recording' do
+          VCR.use_cassette('example', :record => :none) do
+            message.should include('(:none) does not allow requests to be recorded')
+          end
+        end
+
+        it 'does not mention the :once or :none record modes if using the :new_episodes record mode' do
+          VCR.use_cassette('example', :record => :new_episodes) do
+            message.should_not include(':once', ':none')
+          end
+        end
+
+        it 'mentions :allow_playback_repeats if the current cassette has a used matching interaction' do
+          VCR.use_cassette('example') do |cassette|
+            cassette.http_interactions.should respond_to(:has_used_interaction_matching?)
+            cassette.http_interactions.stub(:has_used_interaction_matching? => true)
+            message.should include('allow_playback_repeats')
+          end
+        end
+
+        it 'does not mention :allow_playback_repeats if the current cassette does not have a used matching interaction' do
+          VCR.use_cassette('example') do |cassette|
+            cassette.http_interactions.should respond_to(:has_used_interaction_matching?)
+            cassette.http_interactions.stub(:has_used_interaction_matching? => false)
+            message.should_not include('allow_playback_repeats')
+          end
+        end
+
+        it 'does not mention using a different :match_requests_on option when there are no remaining unused interactions' do
+          VCR.use_cassette('example') do |cassette|
+            cassette.http_interactions.should respond_to(:remaining_unused_interaction_count)
+            cassette.http_interactions.stub(:remaining_unused_interaction_count => 0)
+            message.should_not include('match_requests_on cassette option')
+          end
+        end
+
+        it 'mentions using a different :match_requests_on option when there are some remaining unused interactions' do
+          VCR.use_cassette('example') do |cassette|
+            cassette.http_interactions.should respond_to(:remaining_unused_interaction_count)
+            cassette.http_interactions.stub(:remaining_unused_interaction_count => 1)
+            message.should include('match_requests_on cassette option')
+          end
+        end
+
+        it 'uses the singular (HTTP interaction) when there is only 1 left' do
+          VCR.use_cassette('example') do |cassette|
+            cassette.http_interactions.should respond_to(:remaining_unused_interaction_count)
+            cassette.http_interactions.stub(:remaining_unused_interaction_count => 1)
+            message.should include('1 HTTP interaction ')
+          end
+        end
+
+        it 'uses the plural (HTTP interactions) when there is more than 1 left' do
+          VCR.use_cassette('example') do |cassette|
+            cassette.http_interactions.should respond_to(:remaining_unused_interaction_count)
+            cassette.http_interactions.stub(:remaining_unused_interaction_count => 2)
+            message.should include('2 HTTP interactions ')
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/vcr/library_hooks/excon_spec.rb

@@ -1,12 +1,18 @@
 require 'spec_helper'
 
 describe "Excon hook" do
-  it_behaves_like 'a hook into an HTTP library', 'excon', :status_message_not_exposed
+  # TODO: figure out a way to get disabling VCR to work with Excon
+  #       and allow dirct excon stubs to work.
+  # def directly_stub_request(method, url, response_body)
+  #   ::Excon.stub({ :method => method, :url => url }, { :body => response_body })
+  # end
+
+  it_behaves_like 'a hook into an HTTP library', :excon, 'excon', :status_message_not_exposed
 
   it_performs('version checking', 'Excon',
-    :valid    => %w[ 0.6.5 0.6.99 ],
+    :valid    => %w[ 0.6.5 0.7.9 ],
     :too_low  => %w[ 0.5.99 0.6.4 ],
-    :too_high => %w[ 0.7.0 1.0.0 ]
+    :too_high => %w[ 0.8.0 1.0.0 ]
   ) do
     before(:each) { @orig_version = Excon::VERSION }
     after(:each)  { Excon::VERSION = @orig_version }
@@ -54,9 +60,11 @@ describe "Excon hook" do
   end
 
   context 'when Excon raises an error due to an unexpected response status' do
-    it 'still records properly' do
+    before(:each) do
       VCR.stub(:real_http_connections_allowed? => true)
+    end
 
+    it 'still records properly' do
       VCR.should_receive(:record_http_interaction) do |interaction|
         interaction.response.status.code.should eq(404)
       end
@@ -65,6 +73,15 @@ describe "Excon hook" do
         Excon.get("http://localhost:#{VCR::SinatraApp.port}/not_found", :expects => 200)
       }.to raise_error(Excon::Errors::Error)
     end
+
+    it_behaves_like "request hooks", :excon do
+      undef make_request
+      def make_request(disabled = false)
+        expect {
+          Excon.get(request_url, :expects => 404)
+        }.to raise_error(Excon::Errors::Error)
+      end
+    end
   end
 end
 

data/spec/vcr/library_hooks/fakeweb_spec.rb

@@ -1,7 +1,33 @@
 require 'spec_helper'
 
 describe "FakeWeb hook", :with_monkey_patches => :fakeweb do
-  it_behaves_like 'a hook into an HTTP library', 'net/http'
+  after(:each) do
+    ::FakeWeb.clean_registry
+  end
+
+  def disable_real_connections
+    ::FakeWeb.allow_net_connect = false
+    ::FakeWeb::NetConnectNotAllowedError
+  end
+
+  def enable_real_connections
+    ::FakeWeb.allow_net_connect = true
+  end
+
+  def directly_stub_request(method, url, response_body)
+    ::FakeWeb.register_uri(method, url, :body => response_body)
+  end
+
+  it_behaves_like 'a hook into an HTTP library', :fakeweb, 'net/http' do
+    before(:each) do
+      VCR::LibraryHooks::FakeWeb::RequestHandler.already_seen_requests.clear
+    end
+
+    after(:each) do
+      # assert that we are cleaning up the global state after every request
+      VCR::LibraryHooks::FakeWeb::RequestHandler.already_seen_requests.to_a.should eq([])
+    end
+  end
 
   it_performs('version checking', 'FakeWeb',
     :valid    => %w[ 1.3.0 1.3.1 1.3.99 ],
@@ -46,12 +72,33 @@ describe "FakeWeb hook", :with_monkey_patches => :fakeweb do
 
     it 'records the interaction when Net::HTTP#request is called with a block with a return statement' do
       VCR.should_receive(:record_http_interaction).once
-      perform_get_with_returning_block
+      perform_get_with_returning_block.body.should eq("GET to root")
+    end
+
+    def make_post_request
+      Net::HTTP.new('localhost', VCR::SinatraApp.port).post('/record-and-playback', '')
     end
 
     it 'records the interaction only once, even when Net::HTTP internally recursively calls #request' do
       VCR.should_receive(:record_http_interaction).once
-      Net::HTTP.new('localhost', VCR::SinatraApp.port).post('/', nil)
+      make_post_request
+    end
+
+    it 'properly returns the response body for a post request when recording, stubbing or ignoring the request' do
+      recorded_body = nil
+      VCR.use_cassette("new_cassette", :record => :once) do
+        recorded_body = make_post_request.body
+        recorded_body.should match(/Response \d+/)
+      end
+
+      VCR.use_cassette("new_cassette", :record => :once) do
+        make_post_request.body.should eq(recorded_body)
+      end
+
+      VCR.configuration.ignore_request { |r| true }
+      ignored_body = make_post_request.body
+      ignored_body.should_not eq(recorded_body)
+      ignored_body.should match(/Response \d+/)
     end
   end
 
@@ -80,4 +127,25 @@ describe "FakeWeb hook", :with_monkey_patches => :fakeweb do
       end
     end
   end
+
+  describe "when a SocketError occurs" do
+    before(:each) do
+      VCR.configuration.ignore_request { |r| true }
+    end
+
+    it_behaves_like "request hooks", :fakeweb do
+      undef assert_expected_response
+      def assert_expected_response(response)
+        response.should be_nil
+      end
+
+      undef make_request
+      def make_request(disabled = false)
+        ::Net::HTTP.any_instance.stub(:request_without_vcr).and_raise(SocketError)
+        expect {
+          ::Net::HTTP.get_response(URI(request_url))
+        }.to raise_error(SocketError)
+      end
+    end
+  end
 end