vcr 2.4.0 → 2.5.0

data/spec/vcr/deprecations_spec.rb

@@ -10,7 +10,7 @@ describe VCR, 'deprecations', :disable_warnings do
     it 'yields the configuration object' do
       config_object = nil
       VCR.config { |c| config_object = c }
-      config_object.should be(VCR.configuration)
+      expect(config_object).to be(VCR.configuration)
     end
 
     it 'prints a deprecation warning' do
@@ -22,7 +22,7 @@ describe VCR, 'deprecations', :disable_warnings do
 
   describe "Config" do
     it 'returns the same object referenced by VCR.configuration' do
-      VCR::Config.should be(VCR.configuration)
+      expect(VCR::Config).to be(VCR.configuration)
     end
 
     it 'prints a deprecation warning' do
@@ -40,7 +40,7 @@ describe VCR, 'deprecations', :disable_warnings do
 
   describe "Cassette::MissingERBVariableError" do
     it 'returns VCR::Errors::MissingERBVariableError' do
-      VCR::Cassette::MissingERBVariableError.should be(VCR::Errors::MissingERBVariableError)
+      expect(VCR::Cassette::MissingERBVariableError).to be(VCR::Errors::MissingERBVariableError)
     end
 
     it 'prints a deprecation warning' do

data/spec/vcr/errors_spec.rb

@@ -17,119 +17,119 @@ module VCR
       end
 
       it 'identifies the request by method and URI' do
-        message_for(:method => :post, :uri => 'http://foo.com/').should include(
+        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 'mentions that there is no current cassette' do
-          message.should include('There is currently no cassette in use.')
+          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
-          message.should match(/record this request and play it back.*VCR.use_cassette/m)
+          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
-          message.should include('allow_http_connections_when_no_cassette')
+          expect(message).to 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')
+          expect(message).to 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+\*/)
+          expect(message).not_to match(/\s+\*\s+\*/)
         end
 
         it 'mentions the debug logging configuration option' do
-          message.should include('debug_logger')
+          expect(message).to include('debug_logger')
         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)
+            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
-            message.should include('use the :new_episodes record mode')
+            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
-            message.should include('(:once) does not allow new requests to be recorded')
+            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
-            message.should include('(:none) does not allow requests to be recorded')
+            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
-            message.should_not include(':once', ':none')
+            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|
-            cassette.http_interactions.should respond_to(:has_used_interaction_matching?)
+            expect(cassette.http_interactions).to respond_to(:has_used_interaction_matching?)
             cassette.http_interactions.stub(:has_used_interaction_matching? => true)
-            message.should include('allow_playback_repeats')
+            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|
-            cassette.http_interactions.should respond_to(:has_used_interaction_matching?)
+            expect(cassette.http_interactions).to respond_to(:has_used_interaction_matching?)
             cassette.http_interactions.stub(:has_used_interaction_matching? => false)
-            message.should_not include('allow_playback_repeats')
+            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|
-            cassette.http_interactions.should respond_to(:remaining_unused_interaction_count)
+            expect(cassette.http_interactions).to respond_to(:remaining_unused_interaction_count)
             cassette.http_interactions.stub(:remaining_unused_interaction_count => 0)
-            message.should_not include('match_requests_on cassette option')
+            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|
-            cassette.http_interactions.should respond_to(:remaining_unused_interaction_count)
+            expect(cassette.http_interactions).to respond_to(:remaining_unused_interaction_count)
             cassette.http_interactions.stub(:remaining_unused_interaction_count => 1)
-            message.should include('match_requests_on cassette option')
+            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|
-            cassette.http_interactions.should respond_to(:remaining_unused_interaction_count)
+            expect(cassette.http_interactions).to respond_to(:remaining_unused_interaction_count)
             cassette.http_interactions.stub(:remaining_unused_interaction_count => 1)
-            message.should include('1 HTTP interaction ')
+            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|
-            cassette.http_interactions.should respond_to(:remaining_unused_interaction_count)
+            expect(cassette.http_interactions).to respond_to(:remaining_unused_interaction_count)
             cassette.http_interactions.stub(:remaining_unused_interaction_count => 2)
-            message.should include('2 HTTP interactions ')
+            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
-            message.should include('debug_logger')
+            expect(message).to include('debug_logger')
           end
         end
       end

data/spec/vcr/extensions/net_http_response_spec.rb

@@ -3,24 +3,24 @@ require 'spec_helper'
 describe VCR::Net::HTTPResponse do
   def self.it_allows_the_body_to_be_read(expected_regex)
     it 'allows the body to be read using #body' do
-      response.body.to_s.should =~ expected_regex
+      expect(response.body.to_s).to match expected_regex
     end
 
     it 'allows the body to be read using #read_body' do
-      response.read_body.to_s.should =~ expected_regex
+      expect(response.read_body.to_s).to match expected_regex
     end
 
     it 'allows the body to be read using #read_body with a block' do
       yielded_body = ''
       response { |r| r.read_body { |s| yielded_body << s.to_s } }
-      yielded_body.should =~ expected_regex
+      expect(yielded_body).to match expected_regex
     end
 
     it 'allows the body to be read by passing a destination string to #read_body' do
       dest = ''
       ret_val = response { |r| r.read_body(dest) }.body
-      dest.to_s.should =~ expected_regex
-      ret_val.to_s.should eq(dest)
+      expect(dest.to_s).to match expected_regex
+      expect(ret_val.to_s).to eq(dest)
     end
 
     it 'raises an ArgumentError if both a destination string and a block is given to #read_body' do
@@ -53,8 +53,8 @@ describe VCR::Net::HTTPResponse do
         @response ||= begin
           http = Net::HTTP.new('localhost', VCR::SinatraApp.port)
           res = http.send(http_verb_method, '/', &block)
-          res.should_not be_a(VCR::Net::HTTPResponse)
-          res.should_not be_a(::Net::WebMockHTTPResponse)
+          expect(res).not_to be_a(VCR::Net::HTTPResponse)
+          expect(res).not_to be_a(::Net::WebMockHTTPResponse)
           res
         end
       end

data/spec/vcr/library_hooks/excon_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'support/shared_example_groups/excon'
 
 describe "Excon hook", :with_monkey_patches => :excon do
   # TODO: figure out a way to get disabling VCR to work with Excon
@@ -20,68 +21,12 @@ describe "Excon hook", :with_monkey_patches => :excon do
         end
       end
 
-      recorded.should eq(played_back)
-      recorded.should eq('query: Tolkien')
+      expect(recorded).to eq(played_back)
+      expect(recorded).to eq('query: Tolkien')
     end
   end
 
-  context 'when the request overrides the connection params' do
-    let!(:excon) { ::Excon.new("http://localhost:#{VCR::SinatraApp.port}/") }
-
-    def deep_dup(hash)
-      Marshal.load(Marshal.dump hash)
-    end
-
-    def intercept_request(&interception)
-      orig_new = ::Excon::Connection.method(:new)
-
-      ::Excon::Connection.stub(:new) do |*args1|
-        orig_new.call(*args1).tap do |inst|
-
-          meth = inst.method(:request)
-          inst.stub(:request) do |*args2|
-            interception.call(inst, *args2)
-            meth.call(*args2)
-          end
-        end
-      end
-    end
-
-    it 'runs the real request with the same connection params' do
-      connection_params_1 = deep_dup(excon.connection)
-      connection_params_2 = nil
-
-      intercept_request do |instance, *args|
-        connection_params_2 = deep_dup(instance.connection)
-      end
-
-      VCR.use_cassette("excon") do
-        excon.request(:method => :get, :path => '/foo')
-      end
-
-      connection_params_2.should eq(connection_params_1)
-    end
-  end
-
-  context "when Excon's streaming API is used" do
-    it 'properly records and plays back the response' do
-      VCR.stub(:real_http_connections_allowed? => true)
-      recorded, played_back = [1, 2].map do
-        chunks = []
-
-        VCR.use_cassette('excon_streaming', :record => :once) do
-          Excon.get "http://localhost:#{VCR::SinatraApp.port}/foo", :response_block => lambda { |chunk, remaining_bytes, total_bytes|
-            chunks << chunk
-          }
-        end
-
-        chunks.join
-      end
-
-      recorded.should eq(played_back)
-      recorded.should eq("FOO!")
-    end
-  end
+  include_examples "Excon streaming"
 
   context 'when Excon raises an error due to an unexpected response status' do
     before(:each) do
@@ -90,7 +35,7 @@ describe "Excon hook", :with_monkey_patches => :excon do
 
     it 'still records properly' do
       VCR.should_receive(:record_http_interaction) do |interaction|
-        interaction.response.status.code.should eq(404)
+        expect(interaction.response.status.code).to eq(404)
       end
 
       expect {
@@ -98,29 +43,6 @@ describe "Excon hook", :with_monkey_patches => :excon do
       }.to raise_error(Excon::Errors::Error)
     end
 
-    it 'performs the right number of retries' do
-      connection = Excon.new("http://localhost:#{VCR::SinatraApp.port}/not_found")
-
-      Excon::Connection.stub(:new => connection)
-
-      connection.extend Module.new {
-        def request_kernel_call_counts
-          @request_kernel_call_counts ||= Hash.new(0)
-        end
-
-        def request_kernel(params, &block)
-          request_kernel_call_counts[params[:mock]] += 1
-          super
-        end
-      }
-
-      expect {
-        connection.get(:expects => 200, :idempotent => true, :retry_limit => 3)
-      }.to raise_error(Excon::Errors::Error)
-
-      connection.request_kernel_call_counts.should eq(true => 3, false => 3)
-    end
-
     def error_raised_by
       yield
     rescue => e
@@ -138,7 +60,7 @@ describe "Excon hook", :with_monkey_patches => :excon do
         end
       end
 
-      stubbed_error.class.should be(real_error.class)
+      expect(stubbed_error.class).to be(real_error.class)
     end
 
     it_behaves_like "request hooks", :excon, :recordable do
@@ -153,7 +75,7 @@ describe "Excon hook", :with_monkey_patches => :excon do
 
   describe "VCR.configuration.after_library_hooks_loaded hook" do
     it 'disables the webmock excon adapter so it does not conflict with our typhoeus hook' do
-      ::WebMock::HttpLibAdapters::ExconAdapter.should respond_to(:disable!)
+      expect(::WebMock::HttpLibAdapters::ExconAdapter).to respond_to(:disable!)
       ::WebMock::HttpLibAdapters::ExconAdapter.should_receive(:disable!)
       $excon_after_loaded_hook.conditionally_invoke
     end

data/spec/vcr/library_hooks/fakeweb_spec.rb

@@ -27,7 +27,7 @@ describe "FakeWeb hook", :with_monkey_patches => :fakeweb do
 
     it 'records the request body when using #post_form' do
       VCR.should_receive(:record_http_interaction) do |interaction|
-        interaction.request.body.should eq("q=ruby")
+        expect(interaction.request.body).to eq("q=ruby")
       end
 
       uri = URI("http://localhost:#{VCR::SinatraApp.port}/foo")
@@ -36,16 +36,16 @@ describe "FakeWeb hook", :with_monkey_patches => :fakeweb do
 
     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')
+        expect(interaction.request.headers).not_to have_key('content-type')
+        expect(interaction.request.headers).not_to 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'])
+        expect(interaction.request.headers['content-type']).to eq(['foo/bar'])
+        expect(interaction.request.headers['host']).to eq(['my-example.com'])
       end
       Net::HTTP.new('localhost', VCR::SinatraApp.port).send_request('POST', '/', '', { 'Content-Type' => 'foo/bar', 'Host' => 'my-example.com' })
     end
@@ -58,7 +58,7 @@ 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.body.should eq("GET to root")
+      expect(perform_get_with_returning_block.body).to eq("GET to root")
     end
 
     def make_post_request
@@ -74,17 +74,17 @@ describe "FakeWeb hook", :with_monkey_patches => :fakeweb do
       recorded_body = nil
       VCR.use_cassette("new_cassette", :record => :once) do
         recorded_body = make_post_request.body
-        recorded_body.should match(/Response \d+/)
+        expect(recorded_body).to match(/Response \d+/)
       end
 
       VCR.use_cassette("new_cassette", :record => :once) do
-        make_post_request.body.should eq(recorded_body)
+        expect(make_post_request.body).to 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+/)
+      expect(ignored_body).not_to eq(recorded_body)
+      expect(ignored_body).to match(/Response \d+/)
     end
 
     context 'when the same Net::HTTP request object is used twice' do
@@ -110,7 +110,9 @@ describe "FakeWeb hook", :with_monkey_patches => :fakeweb do
     let(:run_hook) { $fakeweb_after_loaded_hook.conditionally_invoke }
 
     context 'when WebMock has been loaded' do
-      before(:each) { defined?(WebMock).should be_true }
+      before(:each) do
+        expect(defined?(WebMock)).to be_true
+      end
 
       it 'raises an error since FakeWeb and WebMock cannot both be used simultaneously' do
         expect { run_hook }.to raise_error(ArgumentError, /cannot use both/)
@@ -141,7 +143,7 @@ describe "FakeWeb hook", :with_monkey_patches => :fakeweb do
     it_behaves_like "request hooks", :fakeweb, :ignored do
       undef assert_expected_response
       def assert_expected_response(response)
-        response.should be_nil
+        expect(response).to be_nil
       end
 
       undef make_request
@@ -161,7 +163,7 @@ describe "FakeWeb hook", :with_monkey_patches => :fakeweb do
       VCR.turn_off!
 
       uri = URI("http://localhost:#{VCR::SinatraApp.port}/foo")
-      Net::HTTP.get(uri).should eq("FOO!")
+      expect(Net::HTTP.get(uri)).to eq("FOO!")
     end
   end
 end

data/spec/vcr/library_hooks/faraday_spec.rb

@@ -10,7 +10,7 @@ describe "Faraday hook" do
     end
 
     conn.builder.lock!
-    conn.builder.handlers.last(2).map(&:klass).should eq([
+    expect(conn.builder.handlers.last(2).map(&:klass)).to eq([
       VCR::Middleware::Faraday,
       Faraday::Adapter::NetHttp
     ])
@@ -20,7 +20,7 @@ describe "Faraday hook" do
     conn = Faraday.new
 
     conn.builder.lock!
-    conn.builder.handlers.last(2).map(&:klass).should eq([
+    expect(conn.builder.handlers.last(2).map(&:klass)).to eq([
       VCR::Middleware::Faraday,
       Faraday::Adapter::NetHttp
     ])
@@ -34,7 +34,7 @@ describe "Faraday hook" do
     end
 
     conn.builder.lock!
-    conn.builder.handlers.map(&:klass).should eq([
+    expect(conn.builder.handlers.map(&:klass)).to eq([
       VCR::Middleware::Faraday,
       Faraday::Response::Logger,
       Faraday::Adapter::NetHttp
@@ -58,7 +58,7 @@ describe "Faraday hook" do
     end
 
     conn.builder.lock!
-    conn.builder.handlers.map(&:klass).should eq([
+    expect(conn.builder.handlers.map(&:klass)).to eq([
       Faraday::Request::UrlEncoded,
       Faraday::Response::Logger,
       VCR::Middleware::Faraday