mustwin-vcr 2.9.3

data/spec/lib/vcr/configuration_spec.rb

@@ -0,0 +1,326 @@
+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
+
+    it 'resolves the given directory to an absolute path, so VCR continues to work even if the current directory changes' do
+      relative_dir = 'tmp/cassette_library_dir/new_dir'
+      subject.cassette_library_dir = relative_dir
+      absolute_dir = File.join(VCR::SPEC_ROOT.sub(/\/spec\z/, ''), relative_dir)
+      expect(subject.cassette_library_dir).to eq(absolute_dir)
+    end
+  end
+
+  describe '#default_cassette_options' do
+    it 'has a hash with some defaults' do
+      expect(subject.default_cassette_options).to eq({
+        :match_requests_on => VCR::RequestMatcherRegistry::DEFAULT_MATCHERS,
+        :allow_unused_http_interactions => true,
+        :record            => :once,
+        :serialize_with    => :yaml,
+        :persist_with      => :file_system
+      })
+    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 }
+      expect(subject.default_cassette_options).to 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 }
+      expect(subject.default_cassette_options).to include(:record => :once)
+    end
+
+    it "allows defaults to be overriden" do
+      subject.default_cassette_options = { :record => :all }
+      expect(subject.default_cassette_options).to include(:record => :all)
+    end
+
+    it "allows other keys to be set" do
+      subject.default_cassette_options = { :re_record_interval => 10 }
+      expect(subject.default_cassette_options).to 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)
+      expect(matcher_run).to be true
+    end
+  end
+
+  describe '#hook_into' do
+    it 'requires the named library hook' do
+      expect(subject).to receive(:require).with("vcr/library_hooks/fakeweb")
+      expect(subject).to 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
+      expect(called).to be true
+    end
+  end
+
+  describe '#ignore_hosts' do
+    it 'delegates to the current request_ignorer instance' do
+      expect(VCR.request_ignorer).to 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
+      expect(VCR.request_ignorer).to receive(:ignore_localhost=).with(true)
+      subject.ignore_localhost = true
+    end
+  end
+
+  describe '#ignore_request' do
+    let(:uri){ URI('http://foo.com') }
+
+    it 'registers the given block with the request ignorer' do
+      block_called = false
+      subject.ignore_request { |r| block_called = true }
+      VCR.request_ignorer.ignore?(double(:parsed_uri => uri))
+      expect(block_called).to 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
+        subject.allow_http_connections_when_no_cassette = val
+        expect(subject.allow_http_connections_when_no_cassette?).to eq(val)
+      end
+    end
+  end
+
+  describe "request/configuration interactions", :with_monkey_patches => :fakeweb do
+    specify 'the request on the yielded interaction is not typed even though the request given to before_http_request is' do
+      before_record_req = before_request_req = nil
+      VCR.configure do |c|
+        c.before_http_request { |r| before_request_req = r }
+        c.before_record { |i| before_record_req = i.request }
+      end
+
+      VCR.use_cassette("example") do
+        ::Net::HTTP.get_response(URI("http://localhost:#{VCR::SinatraApp.port}/foo"))
+      end
+
+      expect(before_record_req).not_to respond_to(:type)
+      expect(before_request_req).to respond_to(:type)
+    end unless (RUBY_VERSION =~ /^1\.8/ || RUBY_INTERPRETER == :jruby)
+
+    specify 'the filter_sensitive_data option works even when it modifies the URL in a way that makes it an invalid URI' do
+      VCR.configure do |c|
+        c.filter_sensitive_data('<HOST>') { 'localhost' }
+      end
+
+      2.times do
+        VCR.use_cassette("example") do
+          ::Net::HTTP.get_response(URI("http://localhost:#{VCR::SinatraApp.port}/foo"))
+        end
+      end
+    end
+  end
+
+  [:before_record, :before_playback].each do |hook_type|
+    describe "##{hook_type}" do
+      it 'sets up a tag filter' do
+        called = false
+        VCR.configuration.send(hook_type, :my_tag) { called = true }
+        VCR.configuration.invoke_hook(hook_type, double, double(:tags => []))
+        expect(called).to be false
+        VCR.configuration.invoke_hook(hook_type, double, double(:tags => [:my_tag]))
+        expect(called).to be true
+      end
+    end
+  end
+
+  %w[ filter_sensitive_data define_cassette_placeholder ].each do |method|
+    describe "##{method}" do
+      let(:interaction) { double('interaction').as_null_object }
+      before(:each) { allow(interaction).to receive(:filter!) }
+
+      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' })
+        expect(interaction).to receive(:filter!).with('bar', 'foo')
+        subject.invoke_hook(:before_record, interaction, double.as_null_object)
+      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' })
+        expect(interaction).to receive(:filter!).with('foo', 'bar')
+        subject.invoke_hook(:before_playback, interaction, double.as_null_object)
+      end
+
+      it 'tags the before_record hook when given a tag' do
+        expect(subject).to 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
+        expect(subject).to 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.send(method, 'foo', &lambda { |i| yielded_interaction = i; 'bar' })
+        subject.invoke_hook(:before_record, interaction, double.as_null_object)
+        expect(yielded_interaction).to equal(interaction)
+      end
+
+      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, double.as_null_object)
+        expect(yielded_interaction).to equal(interaction)
+      end
+    end
+  end
+
+  describe "#after_http_request" do
+    let(:raw_request) { VCR::Request.new }
+    let(:response)    { VCR::Response.new }
+
+    def request(type)
+      VCR::Request::Typed.new(raw_request, type)
+    end
+
+    it 'handles symbol request predicate filters properly' do
+      yielded = false
+      subject.after_http_request(:stubbed_by_vcr?) { |req| yielded = true }
+      subject.invoke_hook(:after_http_request, request(:stubbed_by_vcr), response)
+      expect(yielded).to be true
+
+      yielded = false
+      subject.invoke_hook(:after_http_request, request(:ignored), response)
+      expect(yielded).to be false
+    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) { double }
+    it 'allows a custom serializer to be registered' do
+      expect { subject.cassette_serializers[:custom] }.to raise_error(ArgumentError)
+      subject.cassette_serializers[:custom] = custom_serializer
+      expect(subject.cassette_serializers[:custom]).to be(custom_serializer)
+    end
+  end
+
+  describe "#cassette_persisters" do
+    let(:custom_persister) { double }
+    it 'allows a custom persister to be registered' do
+      expect { subject.cassette_persisters[:custom] }.to raise_error(ArgumentError)
+      subject.cassette_persisters[:custom] = custom_persister
+      expect(subject.cassette_persisters[:custom]).to be(custom_persister)
+    end
+  end
+
+  describe "#uri_parser=" do
+    let(:custom_parser) { double }
+    it 'allows a custom uri parser to be set' do
+      subject.uri_parser = custom_parser
+      expect(subject.uri_parser).to eq(custom_parser)
+    end
+
+    it "uses Ruby's standard library `URI` as a default" do
+      expect(subject.uri_parser).to eq(URI)
+    end
+  end
+
+  describe "#preserve_exact_body_bytes_for?" do
+    def message_for(body)
+      double(:body => body)
+    end
+
+    context "default hook" do
+      it "returns false when there is no current cassette" do
+        expect(subject.preserve_exact_body_bytes_for?(message_for "string")).to be false
+      end
+
+      it "returns false when the current cassette has been created without the :preserve_exact_body_bytes option" do
+        VCR.insert_cassette('foo')
+        expect(subject.preserve_exact_body_bytes_for?(message_for "string")).to be false
+      end
+
+      it 'returns true when the current cassette has been created with the :preserve_exact_body_bytes option' do
+        VCR.insert_cassette('foo', :preserve_exact_body_bytes => true)
+        expect(subject.preserve_exact_body_bytes_for?(message_for "string")).to be true
+      end
+    end
+
+    it "returns true when the configured block returns true" do
+      subject.preserve_exact_body_bytes { |msg| msg.body == "a" }
+      expect(subject.preserve_exact_body_bytes_for?(message_for "a")).to be true
+      expect(subject.preserve_exact_body_bytes_for?(message_for "b")).to be false
+    end
+
+    it "returns true when any of the registered blocks returns true" do
+      called_hooks = []
+      subject.preserve_exact_body_bytes { called_hooks << :hook_1; false }
+      subject.preserve_exact_body_bytes { called_hooks << :hook_2; true }
+      expect(subject.preserve_exact_body_bytes_for?(message_for "a")).to be true
+      expect(called_hooks).to eq([:hook_1, :hook_2])
+    end
+
+    it "invokes the configured hook with the http message and the current cassette" do
+      VCR.use_cassette('example') do |cassette|
+        expect(cassette).to be_a(VCR::Cassette)
+        message = double(:message)
+
+        yielded_objects = nil
+        subject.preserve_exact_body_bytes { |a, b| yielded_objects = [a, b] }
+        subject.preserve_exact_body_bytes_for?(message)
+        expect(yielded_objects).to eq([message, cassette])
+      end
+    end
+  end
+
+  describe "#configure_rspec_metadata!" do
+    it "only configures the underlying metadata once, no matter how many times it is called" do
+      expect(VCR::RSpec::Metadata).to receive(:configure!).once
+      VCR.configure do |c|
+        c.configure_rspec_metadata!
+      end
+      VCR.configure do |c|
+        c.configure_rspec_metadata!
+      end
+    end
+  end
+end

data/spec/lib/vcr/deprecations_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe VCR, 'deprecations', :disable_warnings do
+  describe ".config" do
+    it 'delegates to VCR.configure' do
+      expect(VCR).to receive(:configure)
+      VCR.config { }
+    end
+
+    it 'yields the configuration object' do
+      config_object = nil
+      VCR.config { |c| config_object = c }
+      expect(config_object).to be(VCR.configuration)
+    end
+
+    it 'prints a deprecation warning' do
+      expect(VCR).to receive(:warn).with(/VCR.config.*deprecated/i)
+
+      VCR.config { }
+    end
+  end
+
+  describe "Config" do
+    it 'returns the same object referenced by VCR.configuration' do
+      expect(VCR::Config).to be(VCR.configuration)
+    end
+
+    it 'prints a deprecation warning' do
+      expect(VCR).to receive(:warn).with(/VCR::Config.*deprecated/i)
+
+      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
+      expect(VCR::Cassette::MissingERBVariableError).to be(VCR::Errors::MissingERBVariableError)
+    end
+
+    it 'prints a deprecation warning' do
+      expect(VCR::Cassette).to receive(:warn).with(/VCR::Cassette::MissingERBVariableError.*deprecated/i)
+
+      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
+      expect(VCR.configuration).to receive(:hook_into).with(:fakeweb, :excon)
+      VCR.configure { |c| c.stub_with :fakeweb, :excon }
+    end
+
+    it 'prints a deprecation warning' do
+      expect(VCR.configuration).to receive(:warn).with(/stub_with.*deprecated/i)
+      VCR.configure { |c| c.stub_with :fakeweb, :excon }
+    end
+  end
+
+  describe "VCR::Middleware::Faraday" do
+    it 'prints a deprecation warning when passed a block' do
+      expect(Kernel).to receive(:warn).with(/Passing a block .* is deprecated/)
+      VCR::Middleware::Faraday.new(double) { }
+    end
+  end
+
+  describe "VCR::RSpec::Macros" do
+    it 'prints a deprecation warning' do
+      expect(Kernel).to receive(:warn).with(/VCR::RSpec::Macros is deprecated/)
+      Class.new.extend(VCR::RSpec::Macros)
+    end
+  end
+end
+

data/spec/lib/vcr/errors_spec.rb

@@ -0,0 +1,162 @@
+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
+        expect(message_for(:method => :post, :uri => 'http://foo.com/')).to include(
+          'POST http://foo.com/'
+        )
+      end
+
+      context 'when there is no current cassette' do
+        it 'identifies the request by its body when the default_cassette_options include the body in the match_requests_on option' do
+          VCR.configuration.default_cassette_options[:match_requests_on] = [:body]
+
+          expect(message_for(:body => 'param=val1')).to include(
+            "Body: param=val1"
+          )
+        end
+
+        it 'mentions that there is no current cassette' do
+          expect(message).to include('There is currently no cassette in use.')
+        end
+
+        it 'mentions that the request can be recorded by inserting a cassette' do
+          expect(message).to match(/record this request and play it back.*VCR.use_cassette/m)
+        end
+
+        it 'mentions the allow_http_connections_when_no_cassette option' do
+          expect(message).to include('allow_http_connections_when_no_cassette')
+        end
+
+        it 'mentions that the request can be ignored' do
+          expect(message).to include('set an `ignore_request` callback')
+        end
+
+        it 'does not double-insert the asterisks for the bullet points' do
+          expect(message).not_to match(/\s+\*\s+\*/)
+        end
+
+        it 'mentions the debug logging configuration option' do
+          expect(message).to include('debug_logger')
+        end
+      end
+
+      context 'when there is a current cassette' do
+        it 'identifies the request by its body when the match_requests_on option includes the body' do
+          VCR.use_cassette('example', :match_requests_on => [:body]) do
+            expect(message_for(:body => 'param=val1')).to include(
+              "Body: param=val1"
+            )
+          end
+        end
+
+        it 'does not identify the request by its body when the cassette match_requests_on option does not include the body but the default_cassette_options do' do
+          VCR.configuration.default_cassette_options[:match_requests_on] = [:body]
+          VCR.use_cassette('example', :match_requests_on => [:uri]) do
+            expect(message_for(:body => 'param=val1')).to_not match(/body/i)
+          end
+        end
+
+        it 'mentions the details about the current casette' do
+          VCR.use_cassette('example') do
+            expect(message).to 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
+            expect(message).to 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
+            expect(message).to 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
+            expect(message).to 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
+            expect(message).not_to 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|
+            expect(cassette.http_interactions).to respond_to(:has_used_interaction_matching?)
+            allow(cassette.http_interactions).to receive(:has_used_interaction_matching?).and_return(true)
+            expect(message).to 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|
+            expect(cassette.http_interactions).to respond_to(:has_used_interaction_matching?)
+            allow(cassette.http_interactions).to receive(:has_used_interaction_matching?).and_return(false)
+            expect(message).not_to 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|
+            expect(cassette.http_interactions).to respond_to(:remaining_unused_interaction_count)
+            allow(cassette.http_interactions).to receive(:remaining_unused_interaction_count).and_return(0)
+            expect(message).not_to 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|
+            expect(cassette.http_interactions).to respond_to(:remaining_unused_interaction_count)
+            allow(cassette.http_interactions).to receive(:remaining_unused_interaction_count).and_return(1)
+            expect(message).to 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|
+            expect(cassette.http_interactions).to respond_to(:remaining_unused_interaction_count)
+            allow(cassette.http_interactions).to receive(:remaining_unused_interaction_count).and_return(1)
+            expect(message).to 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|
+            expect(cassette.http_interactions).to respond_to(:remaining_unused_interaction_count)
+            allow(cassette.http_interactions).to receive(:remaining_unused_interaction_count).and_return(2)
+            expect(message).to include('2 HTTP interactions ')
+          end
+        end
+
+        it 'mentions the debug logging configuration option' do
+          VCR.use_cassette('example', :record => :new_episodes) do
+            expect(message).to include('debug_logger')
+          end
+        end
+      end
+    end
+  end
+end
+