vcr 2.1.1 → 2.2.0

data/spec/vcr/cassette/serializers_spec.rb

@@ -1,3 +1,4 @@
+require 'support/ruby_interpreter'
 require 'vcr/cassette/serializers'
 require 'multi_json'
 begin
@@ -15,7 +16,7 @@ module VCR
               result = serializer.serialize("a" => string)
               serializer.deserialize(result)
             }.to raise_error(error_class, /preserve_exact_body_bytes/)
-          end
+          end unless (RUBY_INTERPRETER == :rubinius && RUBY_VERSION =~ /^1.9/)
         end
       end
 
@@ -75,7 +76,7 @@ module VCR
         end
 
         engines.each do |engine, error|
-          context "when MultiJson is configured to use #{engine.inspect}" do
+          context "when MultiJson is configured to use #{engine.inspect}", :unless => (RUBY_INTERPRETER == :jruby) do
             before { MultiJson.engine = engine }
             it_behaves_like "encoding error handling", :json, error do
               let(:string) { "\xFA" }
@@ -159,7 +160,7 @@ module VCR
           ::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 if defined?(::Psych) && (RUBY_INTERPRETER != :jruby)
       end
     end
   end

data/spec/vcr/cassette_spec.rb

@@ -9,33 +9,17 @@ describe VCR::Cassette do
   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'))
+    it 'delegates the file resolution to the FileSystem persister' do
+      fs = VCR::Cassette::Persisters::FileSystem
+      fs.should respond_to(:absolute_path_to_file).with(1).argument
+      fs.should_receive(:absolute_path_to_file).with("cassette name.yml") { "f.yml" }
+      VCR::Cassette.new("cassette name").file.should eq("f.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')}$/
-    end
-
-    it 'keeps any path separators' do
-      cassette = VCR::Cassette.new("dir/file_name")
-      cassette.file.should =~ /#{Regexp.escape('dir/file_name.yml')}$/
-    end
-
-    VCR::Cassette::VALID_RECORD_MODES.each do |mode|
-      it "returns nil if the cassette_library_dir is not set (when the record mode is :#{mode})" do
-        VCR.configuration.cassette_library_dir = nil
-        cassette = VCR::Cassette.new('the_file', :record => mode)
-        cassette.file.should be_nil
-      end
+    it 'raises a NotImplementedError when a different persister is used' do
+      VCR.cassette_persisters[:a] = stub
+      cassette = VCR::Cassette.new("f", :persist_with => :a)
+      expect { cassette.file }.to raise_error(NotImplementedError)
     end
   end
 
@@ -144,38 +128,36 @@ describe VCR::Cassette do
   end
 
   describe "reading the file from disk" do
-    before(:each) do
-      File.stub(:size? => true)
-    end
-
     let(:empty_cassette_yaml) { YAML.dump("http_interactions" => []) }
 
-    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))
+    it 'optionally renders the file as ERB using the ERBRenderer' do
+      VCR::Cassette::Persisters::FileSystem.stub(:[] => empty_cassette_yaml)
+
+      VCR::Cassette::ERBRenderer.should_receive(:new).with(
+        empty_cassette_yaml, anything, "foo"
+      ).and_return(mock('renderer', :render => empty_cassette_yaml))
 
       VCR::Cassette.new('foo', :record => :new_episodes).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
+      it "passes #{erb.inspect} to the VCR::Cassette::ERBRenderer when given as the :erb option" do
         # test that it overrides the default
         VCR.configuration.default_cassette_options = { :erb => true }
 
-        VCR::Cassette::Reader.should_receive(:new).with(
-          anything, erb
-        ).and_return(mock('reader', :read => empty_cassette_yaml))
+        VCR::Cassette::ERBRenderer.should_receive(:new).with(
+          anything, erb, anything
+        ).and_return(mock('renderer', :render => empty_cassette_yaml))
 
         VCR::Cassette.new('foo', :record => :new_episodes, :erb => erb).http_interactions
       end
 
-      it "passes #{erb.inspect} to the VCR::Cassette::Reader when it is the default :erb option and none is given" do
+      it "passes #{erb.inspect} to the VCR::Cassette::ERBRenderer 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 => empty_cassette_yaml))
+        VCR::Cassette::ERBRenderer.should_receive(:new).with(
+          anything, erb, anything
+        ).and_return(mock('renderer', :render => empty_cassette_yaml))
 
         VCR::Cassette.new('foo', :record => :new_episodes).http_interactions
       end
@@ -205,6 +187,15 @@ describe VCR::Cassette do
       VCR::Cassette.new('empty', :record => :none).send(:previously_recorded_interactions).should eq([])
     end
 
+    let(:custom_persister) { stub("custom persister") }
+
+    it 'reads from the configured persister' do
+      VCR.configuration.cassette_library_dir = nil
+      VCR.cassette_persisters[:foo] = custom_persister
+      custom_persister.should_receive(:[]).with("abc.yml") { "" }
+      VCR::Cassette.new("abc", :persist_with => :foo).http_interactions
+    end
+
     VCR::Cassette::VALID_RECORD_MODES.each do |record_mode|
       stub_requests = (record_mode != :all)
 
@@ -401,6 +392,39 @@ describe VCR::Cassette do
   end
 
   describe '#eject' do
+    let(:custom_persister) { stub("custom persister", :[] => nil) }
+
+    it 'asserts that there are no unused interactions if allow_unused_http_interactions is set to false' do
+      cassette = VCR.insert_cassette("foo", :allow_unused_http_interactions => false)
+
+      interaction_list = cassette.http_interactions
+      interaction_list.should respond_to(:assert_no_unused_interactions!).with(0).arguments
+      interaction_list.should_receive(:assert_no_unused_interactions!)
+
+      cassette.eject
+    end
+
+    it 'does not assert that there are no unused interactions if allow_unused_http_interactions is set to true' do
+      cassette = VCR.insert_cassette("foo", :allow_unused_http_interactions => true)
+
+      interaction_list = cassette.http_interactions
+      interaction_list.should respond_to(:assert_no_unused_interactions!)
+      interaction_list.should_not_receive(:assert_no_unused_interactions!)
+
+      cassette.eject
+    end
+
+    it 'stores the cassette content using the configured persister' do
+      VCR.configuration.cassette_library_dir = nil
+      VCR.cassette_persisters[:foo] = custom_persister
+      cassette = VCR.insert_cassette("foo", :persist_with => :foo)
+      cassette.record_http_interaction http_interaction
+
+      custom_persister.should_receive(:[]=).with("foo.yml", /http_interactions/)
+
+      cassette.eject
+    end
+
     it "writes the serializable_hash to disk as yaml" do
       cassette = VCR::Cassette.new(:eject_test)
       cassette.record_http_interaction http_interaction # so it has one

data/spec/vcr/configuration_spec.rb

@@ -25,8 +25,10 @@ describe VCR::Configuration do
     it 'has a hash with some defaults' do
       subject.default_cassette_options.should eq({
         :match_requests_on => VCR::RequestMatcherRegistry::DEFAULT_MATCHERS,
+        :allow_unused_http_interactions => true,
         :record            => :once,
-        :serialize_with    => :yaml
+        :serialize_with    => :yaml,
+        :persist_with      => :file_system
       })
     end
 
@@ -131,7 +133,7 @@ describe VCR::Configuration do
 
       before_record_req.should_not respond_to(:type)
       before_request_req.should respond_to(:type)
-    end unless RUBY_VERSION =~ /^1\.8/
+    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|
@@ -202,6 +204,26 @@ describe VCR::Configuration do
     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)
+      yielded.should be_true
+
+      yielded = false
+      subject.invoke_hook(:after_http_request, request(:ignored), response)
+      yielded.should 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 {
@@ -219,6 +241,15 @@ describe VCR::Configuration do
     end
   end
 
+  describe "#cassette_persisters" do
+    let(:custom_persister) { stub }
+    it 'allows a custom persister to be registered' do
+      expect { subject.cassette_persisters[:custom] }.to raise_error(ArgumentError)
+      subject.cassette_persisters[:custom] = custom_persister
+      subject.cassette_persisters[:custom].should be(custom_persister)
+    end
+  end
+
   describe "#preserve_exact_body_bytes_for?" do
     def message_for(body)
       stub(:body => body)

data/spec/vcr/library_hooks/fakeweb_spec.rb

@@ -139,4 +139,15 @@ describe "FakeWeb hook", :with_monkey_patches => :fakeweb do
       end
     end
   end
+
+  describe "when VCR is turned off" do
+    it 'allows white listed connections' do
+      ::FakeWeb.allow_net_connect = %r[localhost]
+
+      VCR.turn_off!
+
+      uri = URI("http://localhost:#{VCR::SinatraApp.port}/foo")
+      Net::HTTP.get(uri).should eq("FOO!")
+    end
+  end
 end

data/spec/vcr/library_hooks/faraday_spec.rb

@@ -40,5 +40,29 @@ describe "Faraday hook" do
       Faraday::Adapter::NetHttp
     ])
   end
+
+  it 'prints a warning if the faraday connection stack contains a middleware after the HTTP adapter' do
+    conn = Faraday.new(:url => 'http://sushi.com') do |builder|
+      builder.use Faraday::Adapter::NetHttp
+      builder.use Faraday::Response::Logger
+    end
+
+    conn.builder.should_receive(:warn).with(/Faraday::Response::Logger/)
+    conn.builder.lock!
+  end
+
+  it 'gracefully handles the case where there is no explicit HTTP adapter' do
+    conn = Faraday.new(:url => 'http://sushi.com') do |builder|
+      builder.request  :url_encoded
+      builder.response :logger
+    end
+
+    conn.builder.lock!
+    conn.builder.handlers.map(&:klass).should eq([
+      Faraday::Request::UrlEncoded,
+      Faraday::Response::Logger,
+      VCR::Middleware::Faraday
+    ])
+  end
 end
 

data/spec/vcr/library_hooks/webmock_spec.rb

@@ -5,8 +5,8 @@ describe "WebMock hook", :with_monkey_patches => :webmock do
     ::WebMock.reset!
   end
 
-  def disable_real_connections
-    ::WebMock.disable_net_connect!
+  def disable_real_connections(options = {})
+    ::WebMock.disable_net_connect!(options)
     ::WebMock::NetConnectNotAllowedError
   end
 
@@ -18,6 +18,57 @@ describe "WebMock hook", :with_monkey_patches => :webmock do
     ::WebMock.stub_request(method, url).to_return(:body => response_body)
   end
 
+  describe "our WebMock.after_request hook" do
+    let(:webmock_request) { ::WebMock::RequestSignature.new(:get, "http://foo.com/", :body => "", :headers => {}) }
+    let(:webmock_response) { ::WebMock::Response.new(:body => 'OK', :status => [200, '']) }
+
+    def run_after_request_callback
+      ::WebMock::CallbackRegistry.invoke_callbacks(
+        { :real_request => true },
+        webmock_request,
+        webmock_response)
+    end
+
+    it 'removes the @__typed_vcr_request instance variable so as not to pollute the webmock object' do
+      request = VCR::Request::Typed.new(VCR::Request, :ignored?)
+      webmock_request.instance_variable_set(:@__typed_vcr_request, request)
+
+      run_after_request_callback
+      webmock_request.instance_variables.map(&:to_sym).should_not include(:@__typed_vcr_request)
+    end
+
+    context "when there'ss a bug and the request does not have the @__typed_vcr_request in the after_request callbacks" do
+      let(:warner) { VCR::LibraryHooks::WebMock }
+      before { warner.stub(:warn) }
+
+      it 'records the HTTP interaction properly' do
+        VCR.should_receive(:record_http_interaction) do |i|
+          i.request.uri.should eq("http://foo.com/")
+          i.response.body.should eq("OK")
+        end
+
+        run_after_request_callback
+      end
+
+      it 'invokes the after_http_request hook with an :unknown request' do
+        request = nil
+        VCR.configuration.after_http_request do |req, res|
+          request = req
+        end
+
+        run_after_request_callback
+        request.uri.should eq("http://foo.com/")
+        request.type.should eq(:unknown)
+      end
+
+      it 'prints a warning' do
+        warner.should_receive(:warn).at_least(:once).with(/bug.*after_request/)
+
+        run_after_request_callback
+      end
+    end
+  end
+
   %w[net/http patron httpclient em-http-request curb typhoeus excon].each do |lib|
     other = []
     other << :status_message_not_exposed if lib == 'excon'
@@ -28,5 +79,34 @@ describe "WebMock hook", :with_monkey_patches => :webmock do
         end
       end
     end
+
+    http_lib_unsupported = (RUBY_INTERPRETER != :mri && lib =~ /(typhoeus|curb|patron|em-http)/)
+
+    adapter_module = HTTP_LIBRARY_ADAPTERS.fetch(lib)
+    describe "using #{adapter_module.http_library_name}", :unless => http_lib_unsupported do
+      include adapter_module
+
+      let!(:request_url) { "http://localhost:#{VCR::SinatraApp.port}/foo" }
+
+      context 'when real connections are disabled and VCR is turned off' do
+        it 'can allow connections to localhost' do
+          VCR.turn_off!
+          unexpected_error = disable_real_connections(:allow_localhost => true)
+
+          expect {
+            make_http_request(:get, request_url)
+          }.to_not raise_error(unexpected_error)
+        end
+
+        it 'can allow connections to matching urls' do
+          VCR.turn_off!
+          unexpected_error = disable_real_connections(:allow => /foo/)
+
+          expect {
+            make_http_request(:get, request_url)
+          }.to_not raise_error(unexpected_error)
+        end
+      end
+    end
   end
 end

data/spec/vcr/middleware/faraday_spec.rb

@@ -9,6 +9,38 @@ describe VCR::Middleware::Faraday do
       :not_disableable
   end
 
+  context 'when performing a multipart upload' do
+    let(:connection) do
+      ::Faraday.new("http://localhost:#{VCR::SinatraApp.port}/") do |b|
+        b.request :multipart
+      end
+    end
+
+    def self.test_recording
+      it 'records the request body correctly' do
+        payload = { :file => Faraday::UploadIO.new(__FILE__, 'text/plain') }
+
+        VCR.should_receive(:record_http_interaction) do |i|
+          i.request.headers['Content-Type'].first.should include("multipart")
+          i.request.body.should include(File.read(__FILE__))
+        end
+
+        VCR.use_cassette("upload") do
+          connection.post '/files', payload
+        end
+      end
+    end
+
+    context 'when the net_http adapter is used' do
+      before { connection.builder.adapter :net_http }
+      test_recording
+    end
+
+    context 'when no adapter is used' do
+      test_recording
+    end
+  end
+
   context 'when making parallel requests' do
     include VCRStubHelpers
     let(:connection)         { ::Faraday.new { |b| b.adapter :typhoeus } }

data/spec/vcr/structs_spec.rb

@@ -1,5 +1,7 @@
 # encoding: UTF-8
 
+require 'support/ruby_interpreter'
+
 require 'yaml'
 require 'vcr/structs'
 require 'vcr/errors'
@@ -49,6 +51,12 @@ shared_examples_for "a body normalizer" do
   it 'converts nil to a blank string' do
     instance(nil).body.should eq("")
   end
+
+  it 'raises an error if given another type of object as the body' do
+    expect {
+      instance(:a => "hash")
+    }.to raise_error(ArgumentError)
+  end
 end
 
 module VCR
@@ -190,13 +198,20 @@ module VCR
         end
 
         context 'when the string cannot be encoded as the original encoding' do
+          def verify_encoding_error
+            pending "rubinius 1.9 mode does not raise an encoding error", :if => (RUBY_INTERPRETER == :rubinius && RUBY_VERSION =~ /^1.9/) do
+              expect { "\xFAbc".encode("ISO-8859-1") }.to raise_error(EncodingError)
+            end
+          end
+
           before do
             Request.stub(:warn)
             Response.stub(:warn)
 
             hash['request']['body']  = { 'string' => "\xFAbc", 'encoding' => 'ISO-8859-1' }
             hash['response']['body']  = { 'string' => "\xFAbc", 'encoding' => 'ISO-8859-1' }
-            expect { "\xFAbc".encode("ISO-8859-1") }.to raise_error(EncodingError)
+
+            verify_encoding_error
           end
 
           it 'does not force the encoding' do
@@ -348,6 +363,12 @@ module VCR
       it 'replaces sensitive text in the request URI' do
         filtered.request.uri.should eq('http://example-AAA.com/AAA/')
       end
+
+      it 'handles numbers (such as the port) properly' do
+        request.uri = "http://foo.com:9000/bar"
+        subject.filter!(9000, "<PORT>")
+        request.uri.should eq("http://foo.com:<PORT>/bar")
+      end
     end
   end
 
@@ -365,7 +386,8 @@ module VCR
       end
     end
 
-    [:ignored, :stubbed, :recordable, :unhandled].each do |type|
+    valid_types = [:ignored, :stubbed_by_vcr, :externally_stubbed, :recordable, :unhandled]
+    valid_types.each do |type|
       describe "##{type}?" do
         it "returns true if the type is set to :#{type}" do
           Request::Typed.new(stub, type).send("#{type}?").should be_true
@@ -378,18 +400,34 @@ module VCR
     end
 
     describe "#real?" do
-      [:ignored, :recordable].each do |type|
+      real_types = [:ignored, :recordable]
+      real_types.each do |type|
         it "returns true if the type is set to :#{type}" do
           Request::Typed.new(stub, type).should be_real
         end
       end
 
-      [:stubbed, :unhandled].each do |type|
+      (valid_types - real_types).each do |type|
         it "returns false if the type is set to :#{type}" do
           Request::Typed.new(stub, type).should_not be_real
         end
       end
     end
+
+    describe "#stubbed?" do
+      stubbed_types = [:externally_stubbed, :stubbed_by_vcr]
+      stubbed_types.each do |type|
+        it "returns true if the type is set to :#{type}" do
+          Request::Typed.new(stub, type).should be_stubbed
+        end
+      end
+
+      (valid_types - stubbed_types).each do |type|
+        it "returns false if the type is set to :#{type}" do
+          Request::Typed.new(stub, type).should_not be_stubbed
+        end
+      end
+    end
   end
 
   describe Request do
@@ -561,22 +599,24 @@ module VCR
           end
 
           it "unzips gzipped response" do
-            io = StringIO.new
-
-            writer = Zlib::GzipWriter.new(io)
-            writer << content
-            writer.close
-
-            gzipped = io.string
-            resp = instance(gzipped, 'gzip')
-            resp.should be_compressed
-            expect {
-              resp.decompress.should equal(resp)
-              resp.should_not be_compressed
-              resp.body.should eq(content)
-            }.to change { resp.headers['content-length'] }.
-              from([gzipped.bytesize.to_s]).
-              to([content.bytesize.to_s])
+            pending "rubinius 1.9 mode has a Gzip issue", :if => (RUBY_INTERPRETER == :rubinius && RUBY_VERSION =~ /^1.9/) do
+              io = StringIO.new
+
+              writer = Zlib::GzipWriter.new(io)
+              writer << content
+              writer.close
+
+              gzipped = io.string
+              resp = instance(gzipped, 'gzip')
+              resp.should be_compressed
+              expect {
+                resp.decompress.should equal(resp)
+                resp.should_not be_compressed
+                resp.body.should eq(content)
+              }.to change { resp.headers['content-length'] }.
+                from([gzipped.bytesize.to_s]).
+                to([content.bytesize.to_s])
+            end
           end
 
           it "inflates deflated response" do