vcr 2.5.0 → 2.6.0

data/spec/vcr/library_hooks/webmock_spec.rb

@@ -40,10 +40,10 @@ describe "WebMock hook", :with_monkey_patches => :webmock do
 
     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) }
+      before { allow(warner).to receive(:warn) }
 
       it 'records the HTTP interaction properly' do
-        VCR.should_receive(:record_http_interaction) do |i|
+        expect(VCR).to receive(:record_http_interaction) do |i|
           expect(i.request.uri).to eq("http://foo.com/")
           expect(i.response.body).to eq("OK")
         end
@@ -63,7 +63,7 @@ describe "WebMock hook", :with_monkey_patches => :webmock do
       end
 
       it 'prints a warning' do
-        warner.should_receive(:warn).at_least(:once).with(/bug.*after_request/)
+        expect(warner).to receive(:warn).at_least(:once).with(/bug.*after_request/)
 
         run_after_request_callback
       end
@@ -98,7 +98,7 @@ describe "WebMock hook", :with_monkey_patches => :webmock do
 
           expect {
             make_http_request(:get, request_url)
-          }.to_not raise_error(unexpected_error)
+          }.to_not raise_error
         end
 
         it 'can allow connections to matching urls' do
@@ -107,16 +107,12 @@ describe "WebMock hook", :with_monkey_patches => :webmock do
 
           expect {
             make_http_request(:get, request_url)
-          }.to_not raise_error(unexpected_error)
+          }.to_not raise_error
         end
       end
     end
   end
 
-  it_behaves_like "Excon streaming" do
-    before(:each) do
-      pending "waiting on bblimke/webmock#246 for a fix"
-    end
-  end
+  it_behaves_like "Excon streaming"
 end
 

data/spec/vcr/middleware/faraday_spec.rb

@@ -7,8 +7,7 @@ describe VCR::Middleware::Faraday do
   http_libs.each do |lib|
     it_behaves_like 'a hook into an HTTP library', :faraday, "faraday (w/ #{lib})",
       :status_message_not_exposed,
-      :does_not_support_rotating_responses,
-      :not_disableable
+      :does_not_support_rotating_responses
   end
 
   context 'when performing a multipart upload' do
@@ -22,7 +21,7 @@ describe VCR::Middleware::Faraday do
       it 'records the request body correctly' do
         payload = { :file => Faraday::UploadIO.new(__FILE__, 'text/plain') }
 
-        VCR.should_receive(:record_http_interaction) do |i|
+        expect(VCR).to receive(:record_http_interaction) do |i|
           expect(i.request.headers['Content-Type'].first).to include("multipart")
           expect(i.request.body).to include(File.read(__FILE__))
         end
@@ -43,6 +42,35 @@ describe VCR::Middleware::Faraday do
     end
   end
 
+  context 'when extending the response body with an extension module' do
+    let(:connection) { ::Faraday.new("http://localhost:#{VCR::SinatraApp.port}/") }
+
+    def process_response(response)
+      response.body.extend Module.new { attr_accessor :_response }
+      response.body._response = response
+    end
+
+    it 'does not record the body extensions to the cassette' do
+      3.times do |i|
+        VCR.use_cassette("hack", :record => :new_episodes) do
+          response = connection.get("/foo")
+          process_response(response)
+
+          # Do something different after the first time to
+          # ensure new interactions are added to an existing
+          # cassette.
+          if i > 1
+            response = connection.get("/")
+            process_response(response)
+          end
+        end
+      end
+
+      contents = VCR::Cassette.new("hack").send(:raw_cassette_bytes)
+      expect(contents).not_to include("ruby/object:Faraday::Response")
+    end
+  end
+
   context 'when making parallel requests' do
     include VCRStubHelpers
     let(:connection)         { ::Faraday.new { |b| b.adapter :typhoeus } }
@@ -102,7 +130,7 @@ describe VCR::Middleware::Faraday do
 
     context 'for a recorded request' do
       let!(:inserted_cassette) { VCR.insert_cassette('new_cassette') }
-      before(:each) { VCR.should_receive(:record_http_interaction) }
+      before(:each) { expect(VCR).to receive(:record_http_interaction) }
       it_behaves_like "exclusive library hook"
     end
 
@@ -132,7 +160,7 @@ describe VCR::Middleware::Faraday do
       it 'can be used to eject a cassette after the request is recorded' do
         VCR.configuration.after_http_request { |request| VCR.eject_cassette }
 
-        VCR.should_receive(:record_http_interaction) do |interaction|
+        expect(VCR).to receive(:record_http_interaction) do |interaction|
           expect(VCR.current_cassette).to be(inserted_cassette)
         end
 

data/spec/vcr/middleware/rack_spec.rb

@@ -45,8 +45,8 @@ module VCR
       describe '#call' do
         let(:env_hash) { { :env => :hash } }
         it 'calls the provided rack app and returns its response' do
-          rack_app = mock
-          rack_app.should_receive(:call).with(env_hash).and_return(:response)
+          rack_app = double
+          expect(rack_app).to receive(:call).with(env_hash).and_return(:response)
           instance = described_class.new(rack_app) { |c| c.name 'cassette_name' }
           expect(instance.call(env_hash)).to eq(:response)
         end

data/spec/vcr/request_matcher_registry_spec.rb

@@ -2,11 +2,16 @@ require 'vcr/request_matcher_registry'
 require 'vcr/structs'
 require 'support/limited_uri'
 require 'cgi'
+require 'support/configuration_stubbing'
 
 module VCR
   describe RequestMatcherRegistry do
-    before { VCR.stub_chain(:configuration, :uri_parser) { LimitedURI } }
-    before { VCR.stub_chain(:configuration, :query_parser) { CGI.method(:parse) } }
+    include_context "configuration stubbing"
+
+    before do
+      allow(config).to receive(:uri_parser) { LimitedURI }
+      allow(config).to receive(:query_parser) { CGI.method(:parse) }
+    end
 
     def request_with(values)
       VCR::Request.new.tap do |request|
@@ -20,23 +25,23 @@ module VCR
       it 'registers a request matcher block that can be used later' do
         matcher_called = false
         subject.register(:my_matcher) { |*a| matcher_called = true }
-        subject[:my_matcher].matches?(stub, stub)
+        subject[:my_matcher].matches?(double, double)
         expect(matcher_called).to be_true
       end
 
       context 'when there is already a matcher for the given name' do
         before(:each) do
           subject.register(:foo) { |*a| false }
-          subject.stub :warn
+          allow(subject).to receive :warn
         end
 
         it 'overrides the existing matcher' do
           subject.register(:foo) { |*a| true }
-          expect(subject[:foo].matches?(stub, stub)).to be_true
+          expect(subject[:foo].matches?(double, double)).to be_true
         end
 
         it 'warns that there is a name collision' do
-          subject.should_receive(:warn).with(
+          expect(subject).to receive(:warn).with(
             /WARNING: There is already a VCR request matcher registered for :foo\. Overriding it/
           )
 

data/spec/vcr/structs_spec.rb

@@ -8,6 +8,7 @@ require 'vcr/errors'
 require 'zlib'
 require 'stringio'
 require 'support/limited_uri'
+require 'support/configuration_stubbing'
 
 shared_examples_for "a header normalizer" do
   let(:instance) do
@@ -61,7 +62,8 @@ end
 
 module VCR
   describe HTTPInteraction do
-    before { VCR.stub_chain(:configuration, :uri_parser) { LimitedURI } }
+    include_context "configuration stubbing"
+    before { allow(config).to receive(:uri_parser) { LimitedURI } }
 
     if ''.respond_to?(:encoding)
       def body_hash(key, value)
@@ -77,7 +79,7 @@ module VCR
       let(:now) { Time.now }
 
       it 'is initialized to the current time' do
-        Time.stub(:now => now)
+        allow(Time).to receive(:now).and_return(now)
         expect(VCR::HTTPInteraction.new.recorded_at).to eq(now)
       end
     end
@@ -118,6 +120,18 @@ module VCR
         expect(HTTPInteraction.from_hash(hash).recorded_at).to eq(recorded_at)
       end
 
+      it 'initializes the response adapter_metadata from the hash if it is included' do
+        hash['response']['adapter_metadata'] = { 'foo' => 12 }
+        interaction = HTTPInteraction.from_hash(hash)
+        expect(interaction.response.adapter_metadata).to eq("foo" => 12)
+      end
+
+      it 'works when the response adapter_metadata is missing' do
+        expect(hash['response'].keys).not_to include('adapter_metadata')
+        interaction = HTTPInteraction.from_hash(hash)
+        expect(interaction.response.adapter_metadata).to eq({})
+      end
+
       it 'uses a blank request when the hash lacks one' do
         hash.delete('request')
         i = HTTPInteraction.from_hash(hash)
@@ -192,7 +206,7 @@ module VCR
           expect(string).to be_valid_encoding
           hash['request']['body']  = { 'string' => string, 'encoding' => 'ASCII-8BIT' }
 
-          Request.should_not_receive(:warn)
+          expect(Request).not_to receive(:warn)
           i = HTTPInteraction.from_hash(hash)
           expect(i.request.body).to eq(string)
           expect(i.request.body.bytes.to_a).to eq(string.bytes.to_a)
@@ -201,14 +215,12 @@ module VCR
 
         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
+            expect { "\xFAbc".encode("ISO-8859-1") }.to raise_error(EncodingError)
           end
 
           before do
-            Request.stub(:warn)
-            Response.stub(:warn)
+            allow(Request).to receive(:warn)
+            allow(Response).to receive(:warn)
 
             hash['request']['body']  = { 'string' => "\xFAbc", 'encoding' => 'ISO-8859-1' }
             hash['response']['body']  = { 'string' => "\xFAbc", 'encoding' => 'ISO-8859-1' }
@@ -225,8 +237,8 @@ module VCR
           end
 
           it 'prints a warning and informs users of the :preserve_exact_body_bytes option' do
-            Request.should_receive(:warn).with(/ISO-8859-1.*preserve_exact_body_bytes/)
-            Response.should_receive(:warn).with(/ISO-8859-1.*preserve_exact_body_bytes/)
+            expect(Request).to receive(:warn).with(/ISO-8859-1.*preserve_exact_body_bytes/)
+            expect(Response).to receive(:warn).with(/ISO-8859-1.*preserve_exact_body_bytes/)
 
             HTTPInteraction.from_hash(hash)
           end
@@ -235,9 +247,11 @@ module VCR
     end
 
     describe "#to_hash" do
+      include_context "configuration stubbing"
+
       before(:each) do
-        VCR.stub_chain(:configuration, :preserve_exact_body_bytes_for?).and_return(false)
-        VCR.stub_chain(:configuration, :uri_parser).and_return(URI)
+        allow(config).to receive(:preserve_exact_body_bytes_for?).and_return(false)
+        allow(config).to receive(:uri_parser).and_return(URI)
       end
 
       let(:hash) { interaction.to_hash }
@@ -265,8 +279,29 @@ module VCR
         })
       end
 
+      it 'includes the response adapter metadata when it is not empty' do
+        interaction.response.adapter_metadata['foo'] = 17
+        expect(hash['response']['adapter_metadata']).to eq('foo' => 17)
+      end
+
+      it 'does not include the response adapter metadata when it is empty' do
+        expect(interaction.response.adapter_metadata).to eq({})
+        expect(hash['response'].keys).not_to include('adapter_metadata')
+      end
+
+      context "when the body is extended with a module and some state" do
+        it 'serializes to YAML w/o the extra state' do
+          interaction.request.body.extend Module.new { attr_accessor :foo }
+          interaction.response.body.extend Module.new { attr_accessor :foo }
+          interaction.request.body.foo = 98765
+          interaction.response.body.foo = 98765
+
+          expect(YAML.dump(interaction.to_hash)).not_to include("98765")
+        end
+      end
+
       it 'encodes the body as base64 when the configuration is so set' do
-        VCR.stub_chain(:configuration, :preserve_exact_body_bytes_for?).and_return(true)
+        allow(config).to receive(:preserve_exact_body_bytes_for?).and_return(true)
         expect(hash['request']['body']).to eq(body_hash('base64_string', Base64.encode64('req body')))
         expect(hash['response']['body']).to eq(body_hash('base64_string', Base64.encode64('res body')))
       end
@@ -291,19 +326,24 @@ module VCR
         assert_yielded_keys hash['response'], 'status', 'headers', 'body', 'http_version'
         assert_yielded_keys hash['response']['status'], 'code', 'message'
       end
+
+      it 'yields `adapter_metadata` if it has any data' do
+        interaction.response.adapter_metadata['foo'] = 17
+        assert_yielded_keys hash['response'], 'status', 'headers', 'body', 'http_version', 'adapter_metadata'
+      end
     end
 
     describe "#parsed_uri" do
       before :each do
-        uri_parser.stub(:parse).and_return(uri)
-        VCR.stub_chain(:configuration, :uri_parser).and_return(uri_parser)
+        allow(uri_parser).to receive(:parse).and_return(uri)
+        allow(config).to receive(:uri_parser).and_return(uri_parser)
       end
 
-      let(:uri_parser){ mock('parser') }
-      let(:uri){ mock('uri').as_null_object }
+      let(:uri_parser){ double('parser') }
+      let(:uri){ double('uri').as_null_object }
 
       it "parses the uri using the current uri_parser" do
-        uri_parser.should_receive(:parse).with(request.uri)
+        expect(uri_parser).to receive(:parse).with(request.uri)
         request.parsed_uri
       end
 
@@ -314,7 +354,11 @@ module VCR
   end
 
   describe HTTPInteraction::HookAware do
-    before { VCR.stub_chain(:configuration, :uri_parser) { LimitedURI } }
+    include_context "configuration stubbing"
+
+    before do
+      allow(config).to receive(:uri_parser) { LimitedURI }
+    end
 
     let(:response_status) { VCR::ResponseStatus.new(200, "OK foo") }
     let(:body) { "The body foo this is (foo-Foo)" }
@@ -399,14 +443,14 @@ module VCR
   describe Request::Typed do
     [:uri, :method, :headers, :body].each do |method|
       it "delegates ##{method} to the request" do
-        request = stub(method => "delegated value")
+        request = double(method => "delegated value")
         expect(Request::Typed.new(request, :type).send(method)).to eq("delegated value")
       end
     end
 
     describe "#type" do
       it 'returns the initialized type' do
-        expect(Request::Typed.new(stub, :ignored).type).to be(:ignored)
+        expect(Request::Typed.new(double, :ignored).type).to be(:ignored)
       end
     end
 
@@ -414,11 +458,11 @@ module VCR
     valid_types.each do |type|
       describe "##{type}?" do
         it "returns true if the type is set to :#{type}" do
-          expect(Request::Typed.new(stub, type).send("#{type}?")).to be_true
+          expect(Request::Typed.new(double, type).send("#{type}?")).to be_true
         end
 
         it "returns false if the type is set to :other" do
-          expect(Request::Typed.new(stub, :other).send("#{type}?")).to be_false
+          expect(Request::Typed.new(double, :other).send("#{type}?")).to be_false
         end
       end
     end
@@ -427,13 +471,13 @@ module VCR
       real_types = [:ignored, :recordable]
       real_types.each do |type|
         it "returns true if the type is set to :#{type}" do
-          expect(Request::Typed.new(stub, type)).to be_real
+          expect(Request::Typed.new(double, type)).to be_real
         end
       end
 
       (valid_types - real_types).each do |type|
         it "returns false if the type is set to :#{type}" do
-          expect(Request::Typed.new(stub, type)).not_to be_real
+          expect(Request::Typed.new(double, type)).not_to be_real
         end
       end
     end
@@ -442,20 +486,24 @@ module VCR
       stubbed_types = [:externally_stubbed, :stubbed_by_vcr]
       stubbed_types.each do |type|
         it "returns true if the type is set to :#{type}" do
-          expect(Request::Typed.new(stub, type)).to be_stubbed
+          expect(Request::Typed.new(double, type)).to be_stubbed
         end
       end
 
       (valid_types - stubbed_types).each do |type|
         it "returns false if the type is set to :#{type}" do
-          expect(Request::Typed.new(stub, type)).not_to be_stubbed
+          expect(Request::Typed.new(double, type)).not_to be_stubbed
         end
       end
     end
   end
 
   describe Request do
-    before { VCR.stub_chain(:configuration, :uri_parser) { LimitedURI } }
+    include_context "configuration stubbing"
+
+    before do
+      allow(config).to receive(:uri_parser) { LimitedURI }
+    end
 
     describe '#method' do
       subject { VCR::Request.new(:get) }
@@ -518,7 +566,7 @@ module VCR
       end
 
       it 'can be cast to a proc' do
-        Fiber.should_receive(:yield)
+        expect(Fiber).to receive(:yield)
         lambda(&subject).call
       end
     end if RUBY_VERSION > '1.9'
@@ -549,6 +597,27 @@ module VCR
       end
     end
 
+    describe "#adapter_metadata" do
+      it 'returns the hash given as the last #initialize argument' do
+        response = Response.new(
+          ResponseStatus.new(200, "OK"),
+          {}, "the body", "1.1",
+          { "meta" => "value" }
+        )
+
+        expect(response.adapter_metadata).to eq("meta" => "value")
+      end
+
+      it 'returns a blank hash when nil is passed to #initialize' do
+        response = Response.new(
+          ResponseStatus.new(200, "OK"),
+          {}, "the body", "1.1", nil
+        )
+
+        expect(response.adapter_metadata).to eq({})
+      end
+    end
+
     describe '#update_content_length_header' do
       %w[ content-length Content-Length ].each do |header|
         context "for the #{header} header" do
@@ -625,24 +694,22 @@ module VCR
           end
 
           it "unzips gzipped response" do
-            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')
-              expect(resp).to be_compressed
-              expect {
-                expect(resp.decompress).to equal(resp)
-                expect(resp).not_to be_compressed
-                expect(resp.body).to eq(content)
-              }.to change { resp.headers['content-length'] }.
-                from([gzipped.bytesize.to_s]).
-                to([content.bytesize.to_s])
-            end
+            io = StringIO.new
+
+            writer = Zlib::GzipWriter.new(io)
+            writer << content
+            writer.close
+
+            gzipped = io.string
+            resp = instance(gzipped, 'gzip')
+            expect(resp).to be_compressed
+            expect {
+              expect(resp.decompress).to equal(resp)
+              expect(resp).not_to be_compressed
+              expect(resp.body).to eq(content)
+            }.to change { resp.headers['content-length'] }.
+              from([gzipped.bytesize.to_s]).
+              to([content.bytesize.to_s])
           end
 
           it "inflates deflated response" do