vcr 1.11.3 → 2.0.0.beta1

data/spec/vcr/configuration_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe VCR::Configuration do
+  describe '#cassette_library_dir=' do
+    let(:tmp_dir) { VCR::SPEC_ROOT + '/../tmp/cassette_library_dir/new_dir' }
+    after(:each) { FileUtils.rm_rf tmp_dir }
+
+    it 'creates the directory if it does not exist' do
+      expect { subject.cassette_library_dir = tmp_dir }.to change { File.exist?(tmp_dir) }.from(false).to(true)
+    end
+
+    it 'does not raise an error if given nil' do
+      expect { subject.cassette_library_dir = nil }.to_not raise_error
+    end
+  end
+
+  describe '#default_cassette_options' do
+    it 'has a hash with some defaults' do
+      subject.default_cassette_options.should eq({
+        :match_requests_on => VCR::RequestMatcherRegistry::DEFAULT_MATCHERS,
+        :record            => :once
+      })
+    end
+
+    it "returns #{VCR::RequestMatcherRegistry::DEFAULT_MATCHERS.inspect} for :match_requests_on when other defaults have been set" do
+      subject.default_cassette_options = { :record => :none }
+      subject.default_cassette_options.should include(:match_requests_on => VCR::RequestMatcherRegistry::DEFAULT_MATCHERS)
+    end
+
+    it "returns :once for :record when other defaults have been set" do
+      subject.default_cassette_options = { :erb => :true }
+      subject.default_cassette_options.should include(:record => :once)
+    end
+
+    it "allows defaults to be overriden" do
+      subject.default_cassette_options = { :record => :all }
+      subject.default_cassette_options.should include(:record => :all)
+    end
+
+    it "allows other keys to be set" do
+      subject.default_cassette_options = { :re_record_interval => 10 }
+      subject.default_cassette_options.should include(:re_record_interval => 10)
+    end
+  end
+
+  describe '#register_request_matcher' do
+    it 'registers the given request matcher' do
+      expect {
+        VCR.request_matchers[:custom]
+      }.to raise_error(VCR::UnregisteredMatcherError)
+
+      matcher_run = false
+      subject.register_request_matcher(:custom) { |r1, r2| matcher_run = true }
+      VCR.request_matchers[:custom].matches?(:r1, :r2)
+      matcher_run.should be_true
+    end
+  end
+
+  describe '#hook_into' do
+    it 'requires the named library hook' do
+      subject.should_receive(:require).with("vcr/library_hooks/fakeweb")
+      subject.should_receive(:require).with("vcr/library_hooks/excon")
+      subject.hook_into :fakeweb, :excon
+    end
+
+    it 'raises an error for unsupported stubbing libraries' do
+      expect {
+        subject.hook_into :unsupported_library
+      }.to raise_error(ArgumentError, /unsupported_library is not a supported VCR HTTP library hook/i)
+    end
+
+    it 'invokes the after_library_hooks_loaded hooks' do
+      called = false
+      subject.after_library_hooks_loaded { called = true }
+      subject.hook_into :fakeweb
+      called.should be_true
+    end
+  end
+
+  describe '#ignore_hosts' do
+    it 'delegates to the current request_ignorer instance' do
+      VCR.request_ignorer.should_receive(:ignore_hosts).with('example.com', 'example.net')
+      subject.ignore_hosts 'example.com', 'example.net'
+    end
+  end
+
+  describe '#ignore_localhost=' do
+    it 'delegates to the current request_ignorer instance' do
+      VCR.request_ignorer.should_receive(:ignore_localhost=).with(true)
+      subject.ignore_localhost = 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
+        subject.allow_http_connections_when_no_cassette = val
+        subject.allow_http_connections_when_no_cassette?.should eq(val)
+      end
+    end
+  end
+
+  describe '#filter_sensitive_data' 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_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 '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_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 '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_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)
+    end
+  end
+end

data/spec/vcr/deprecations_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe VCR, 'deprecations', :disable_warnings do
+  describe ".config" do
+    it 'delegates to VCR.configure' do
+      VCR.should_receive(:configure)
+      VCR.config { }
+    end
+
+    it 'yields the configuration object' do
+      config_object = nil
+      VCR.config { |c| config_object = c }
+      config_object.should be(VCR.configuration)
+    end
+
+    it 'prints a deprecation warning' do
+      VCR.should_receive(:warn).with \
+        "WARNING: `VCR.config` is deprecated.  Use VCR.configure instead."
+
+      VCR.config { }
+    end
+  end
+
+  describe "Config" do
+    it 'returns the same object referenced by VCR.configuration' do
+      VCR::Config.should be(VCR.configuration)
+    end
+
+    it 'prints a deprecation warning' do
+      VCR.should_receive(:warn).with \
+        "WARNING: `VCR::Config` is deprecated.  Use VCR.configuration instead."
+
+      VCR::Config
+    end
+
+    it 'preserves the normal undefined constant behavior' do
+      expect {
+        VCR::SomeUndefinedConstant
+      }.to raise_error(NameError)
+    end
+  end
+
+  describe "Cassette::MissingERBVariableError" do
+    it 'returns VCR::Errors::MissingERBVariableError' do
+      VCR::Cassette::MissingERBVariableError.should be(VCR::Errors::MissingERBVariableError)
+    end
+
+    it 'prints a deprecation warning' do
+      VCR::Cassette.should_receive(:warn).with \
+        "WARNING: `VCR::Cassette::MissingERBVariableError` is deprecated.  Use `VCR::Errors::MissingERBVariableError` instead."
+
+      VCR::Cassette::MissingERBVariableError
+    end
+
+    it 'preserves the normal undefined constant behavior' do
+      expect {
+        VCR::Cassette::SomeUndefinedConstant
+      }.to raise_error(NameError)
+    end
+  end
+
+  describe "VCR.configure { |c| c.stub_with ... }" do
+    it 'delegates to #hook_into' do
+      VCR.configuration.should_receive(:hook_into).with(:fakeweb, :excon)
+      VCR.configure { |c| c.stub_with :fakeweb, :excon }
+    end
+
+    it 'prints a deprecation warning' do
+      VCR.configuration.should_receive(:warn).with \
+        "WARNING: `VCR.config { |c| c.stub_with ... }` is deprecated. Use `VCR.configure { |c| c.hook_into ... }` instead."
+
+      VCR.configure { |c| c.stub_with :fakeweb, :excon }
+    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/)
+      VCR::Middleware::Faraday.new(stub) { }
+    end
+  end
+end
+

data/spec/vcr/{http_stubbing_adapters → library_hooks}/excon_spec.rb

@@ -1,12 +1,9 @@
 require 'spec_helper'
 
-describe VCR::HttpStubbingAdapters::Excon do
-  it_behaves_like 'an http stubbing adapter',
-    ['excon'],
-    [:method, :uri, :host, :path, :body, :headers],
-    :status_message_not_exposed
+describe "Excon hook" do
+  it_behaves_like 'a hook into an HTTP library', 'excon', :status_message_not_exposed
 
-  it_performs('version checking',
+  it_performs('version checking', 'Excon',
     :valid    => %w[ 0.6.5 0.6.99 ],
     :too_low  => %w[ 0.5.99 0.6.4 ],
     :too_high => %w[ 0.7.0 1.0.0 ]
@@ -24,7 +21,7 @@ describe VCR::HttpStubbingAdapters::Excon do
     let(:excon) { ::Excon.new("http://localhost:#{VCR::SinatraApp.port}/search") }
 
     it 'properly records and plays back the response' do
-      described_class.http_connections_allowed = true
+      VCR.stub(:real_http_connections_allowed? => true)
       recorded, played_back = [1, 2].map do
         VCR.use_cassette('excon_query', :record => :once) do
           excon.request(:method => :get, :query => { :q => 'Tolkien' }).body
@@ -38,7 +35,7 @@ describe VCR::HttpStubbingAdapters::Excon do
 
   context "when Excon's streaming API is used" do
     it 'properly records and plays back the response' do
-      described_class.http_connections_allowed = true
+      VCR.stub(:real_http_connections_allowed? => true)
       recorded, played_back = [1, 2].map do
         chunks = []
 
@@ -58,7 +55,7 @@ describe VCR::HttpStubbingAdapters::Excon do
 
   context 'when Excon raises an error due to an unexpected response status' do
     it 'still records properly' do
-      described_class.http_connections_allowed = true
+      VCR.stub(:real_http_connections_allowed? => true)
 
       VCR.should_receive(:record_http_interaction) do |interaction|
         interaction.response.status.code.should eq(404)

data/spec/vcr/library_hooks/fakeweb_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe "FakeWeb hook", :with_monkey_patches => :fakeweb do
+  it_behaves_like 'a hook into an HTTP library', 'net/http'
+
+  it_performs('version checking', 'FakeWeb',
+    :valid    => %w[ 1.3.0 1.3.1 1.3.99 ],
+    :too_low  => %w[ 1.2.8 1.1.30 0.30.30 ],
+    :too_high => %w[ 1.4.0 1.10.0 2.0.0 ]
+  ) do
+    before(:each) { @orig_version = FakeWeb::VERSION }
+    after(:each)  { FakeWeb::VERSION = @orig_version }
+
+    # Cannot be regular method def as that raises a "dynamic constant assignment" error
+    define_method :stub_version do |version|
+      FakeWeb::VERSION = version
+    end
+  end
+
+  describe "some specific Net::HTTP edge cases" do
+    before(:each) do
+      VCR.stub(:real_http_connections_allowed? => true)
+    end
+
+    it "does not record headers for which Net::HTTP sets defaults near the end of the real request" do
+      VCR.should_receive(:record_http_interaction) do |interaction|
+        interaction.request.headers.should_not have_key('content-type')
+        interaction.request.headers.should_not have_key('host')
+      end
+      Net::HTTP.new('localhost', VCR::SinatraApp.port).send_request('POST', '/', '', { 'x-http-user' => 'me' })
+    end
+
+    it "records headers for which Net::HTTP usually sets defaults when the user manually sets their values" do
+      VCR.should_receive(:record_http_interaction) do |interaction|
+        interaction.request.headers['content-type'].should eq(['foo/bar'])
+        interaction.request.headers['host'].should eq(['my-example.com'])
+      end
+      Net::HTTP.new('localhost', VCR::SinatraApp.port).send_request('POST', '/', '', { 'Content-Type' => 'foo/bar', 'Host' => 'my-example.com' })
+    end
+
+    def perform_get_with_returning_block
+      Net::HTTP.new('localhost', VCR::SinatraApp.port).request(Net::HTTP::Get.new('/', {})) do |response|
+        return response
+      end
+    end
+
+    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
+    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)
+    end
+  end
+
+  describe "VCR.configuration.after_library_hooks_loaded hook", :disable_warnings do
+    before(:each) do
+      load "vcr/library_hooks/fakeweb.rb" # to re-add the hook since it's cleared by each test
+    end
+
+    let(:run_hook) { VCR.configuration.invoke_hook(:after_library_hooks_loaded) }
+
+    context 'when WebMock has been loaded' do
+      before(:each) { defined?(WebMock).should be_true }
+
+      it 'raises an error since FakeWeb and WebMock cannot both be used simultaneously' do
+        expect { run_hook }.to raise_error(ArgumentError, /cannot use both/)
+      end
+    end
+
+    context 'when WebMock has not been loaded' do
+      let!(:orig_webmock_constant) { ::WebMock }
+      before(:each) { Object.send(:remove_const, :WebMock) }
+      after(:each)  { ::WebMock = orig_webmock_constant }
+
+      it 'does not raise an error' do
+        run_hook # should not raise an error
+      end
+    end
+  end
+end

data/spec/vcr/{http_stubbing_adapters → library_hooks}/typhoeus_spec.rb

@@ -1,14 +1,9 @@
 require 'spec_helper'
 
-describe VCR::HttpStubbingAdapters::Typhoeus do
-  before(:each) do
-    ::Typhoeus::Hydra.stubs = []
-    ::Typhoeus::Hydra.allow_net_connect = true
-  end
-
-  it_behaves_like 'an http stubbing adapter', ['typhoeus'], [:method, :uri, :host, :path, :body, :headers]
+describe "Typhoeus hook", :with_monkey_patches => :typhoeus do
+  it_behaves_like 'a hook into an HTTP library', 'typhoeus'
 
-  it_performs('version checking',
+  it_performs('version checking', 'Typhoeus',
     :valid    => %w[ 0.2.1 0.2.99 ],
     :too_low  => %w[ 0.1.0 0.1.31 0.2.0 ],
     :too_high => %w[ 0.3.0 1.0.0 ]
@@ -22,10 +17,11 @@ describe VCR::HttpStubbingAdapters::Typhoeus do
     end
   end
 
-  describe ".after_adapters_loaded" do
-    it 'disables the webmock typhoeus adapter so it does not conflict with our typhoeus adapter' do
+  describe "VCR.configuration.after_library_hooks_loaded hook", :disable_warnings do
+    it 'disables the webmock typhoeus adapter so it does not conflict with our typhoeus hook' do
+      load "vcr/library_hooks/typhoeus.rb" # to re-add the hook since it's cleared by each test
       ::WebMock::HttpLibAdapters::TyphoeusAdapter.should_receive(:disable!)
-      described_class.after_adapters_loaded
+      VCR.configuration.invoke_hook(:after_library_hooks_loaded)
     end
   end
 end unless RUBY_PLATFORM == 'java'

data/spec/vcr/library_hooks/webmock_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe "WebMock hook", :with_monkey_patches => :webmock do
+  %w[net/http patron httpclient em-http-request curb typhoeus].each do |lib|
+    it_behaves_like 'a hook into an HTTP library', lib
+  end
+
+  it_performs('version checking', 'WebMock',
+    :valid    => %w[ 1.7.0 1.7.99 ],
+    :too_low  => %w[ 0.9.9 0.9.10 0.1.30 1.0.30 1.6.9 ],
+    :too_high => %w[ 1.8.0 1.10.0 2.0.0 ]
+  ) do
+    def stub_version(version)
+      WebMock.stub(:version).and_return(version)
+    end
+  end
+end

data/spec/vcr/library_hooks_spec.rb

@@ -0,0 +1,51 @@
+require 'vcr/library_hooks'
+
+module VCR
+  describe LibraryHooks do
+    describe '#disabled?' do
+      it 'returns false by default for any argument given' do
+        subject.disabled?(:foo).should be_false
+        subject.disabled?(:bar).should be_false
+      end
+
+      context 'when a library hook is exclusively enabled' do
+        it 'returns false for the exclusively enabled hook' do
+          faraday_disabled = nil
+
+          subject.exclusively_enabled :faraday do
+            faraday_disabled = subject.disabled?(:faraday)
+          end
+
+          faraday_disabled.should eq(false)
+        end
+
+        it 'returns true for every other argument given' do
+          foo_disabled = bar_disabled = nil
+
+          subject.exclusively_enabled :faraday do
+            foo_disabled = subject.disabled?(:foo)
+            bar_disabled = subject.disabled?(:bar)
+          end
+
+          foo_disabled.should be_true
+          bar_disabled.should be_true
+        end
+      end
+    end
+
+    describe '#exclusively_enabled' do
+      it 'restores all hook to being enabled when the block completes' do
+        subject.exclusively_enabled(:faraday) { }
+        subject.disabled?(:foo).should be_false
+        subject.disabled?(:faraday).should be_false
+      end
+
+      it 'restores all hooks to being enabled when the block completes, even if there is an error' do
+        subject.exclusively_enabled(:faraday) { raise "boom" } rescue
+        subject.disabled?(:foo).should be_false
+        subject.disabled?(:faraday).should be_false
+      end
+    end
+  end
+end
+