vcr 2.4.0 → 2.5.0

data/spec/vcr/library_hooks/typhoeus_0.4_spec.rb

@@ -26,6 +26,11 @@ describe "Typhoeus 0.4 hook", :with_monkey_patches => :typhoeus_0_4 do
       ::WebMock::HttpLibAdapters::TyphoeusAdapter.should_receive(:disable!)
       $typhoeus_after_loaded_hook.conditionally_invoke
     end
+
+    it "warns about Typhoeus 0.4 deprecation" do
+      ::Kernel.should_receive(:warn).with("WARNING: VCR's Typhoeus 0.4 integration is deprecated and will be removed in VCR 3.0.")
+      $typhoeus_0_4_after_loaded_hook.conditionally_invoke
+    end
   end
 end if RUBY_INTERPRETER == :mri && ::Typhoeus::VERSION.to_f < 0.5
 

data/spec/vcr/library_hooks/typhoeus_spec.rb

@@ -61,7 +61,7 @@ describe "Typhoeus hook", :with_monkey_patches => :typhoeus do
       recorded = make_requests
       played_back = make_requests
 
-      played_back.should eq(recorded)
+      expect(played_back).to eq(recorded)
     end
   end
 
@@ -77,9 +77,9 @@ describe "Typhoeus hook", :with_monkey_patches => :typhoeus do
     it 'recorded and played back properly' do
       recorded = make_single_request
       played_back = make_single_request
-      recorded.should_not be_nil
+      expect(recorded).not_to be_nil
 
-      played_back.should eq(recorded)
+      expect(played_back).to eq(recorded)
     end
   end
 end

data/spec/vcr/library_hooks/webmock_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'support/shared_example_groups/excon'
 
 describe "WebMock hook", :with_monkey_patches => :webmock do
   after(:each) do
@@ -34,7 +35,7 @@ describe "WebMock hook", :with_monkey_patches => :webmock do
       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)
+      expect(webmock_request.instance_variables.map(&:to_sym)).not_to 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
@@ -43,8 +44,8 @@ describe "WebMock hook", :with_monkey_patches => :webmock do
 
       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")
+          expect(i.request.uri).to eq("http://foo.com/")
+          expect(i.response.body).to eq("OK")
         end
 
         run_after_request_callback
@@ -57,8 +58,8 @@ describe "WebMock hook", :with_monkey_patches => :webmock do
         end
 
         run_after_request_callback
-        request.uri.should eq("http://foo.com/")
-        request.type.should eq(:unknown)
+        expect(request.uri).to eq("http://foo.com/")
+        expect(request.type).to eq(:unknown)
       end
 
       it 'prints a warning' do
@@ -111,4 +112,11 @@ describe "WebMock hook", :with_monkey_patches => :webmock do
       end
     end
   end
+
+  it_behaves_like "Excon streaming" do
+    before(:each) do
+      pending "waiting on bblimke/webmock#246 for a fix"
+    end
+  end
 end
+

data/spec/vcr/library_hooks_spec.rb

@@ -4,8 +4,8 @@ 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
+        expect(subject.disabled?(:foo)).to be_false
+        expect(subject.disabled?(:bar)).to be_false
       end
 
       context 'when a library hook is exclusively enabled' do
@@ -16,7 +16,7 @@ module VCR
             faraday_disabled = subject.disabled?(:faraday)
           end
 
-          faraday_disabled.should eq(false)
+          expect(faraday_disabled).to eq(false)
         end
 
         it 'returns true for every other argument given' do
@@ -27,8 +27,8 @@ module VCR
             bar_disabled = subject.disabled?(:bar)
           end
 
-          foo_disabled.should be_true
-          bar_disabled.should be_true
+          expect(foo_disabled).to be_true
+          expect(bar_disabled).to be_true
         end
       end
     end
@@ -36,14 +36,14 @@ module VCR
     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
+        expect(subject.disabled?(:foo)).to be_false
+        expect(subject.disabled?(:faraday)).to 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
+        expect(subject.disabled?(:foo)).to be_false
+        expect(subject.disabled?(:faraday)).to be_false
       end
     end
   end

data/spec/vcr/middleware/faraday_spec.rb

@@ -23,8 +23,8 @@ describe VCR::Middleware::Faraday 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__))
+          expect(i.request.headers['Content-Type'].first).to include("multipart")
+          expect(i.request.body).to include(File.read(__FILE__))
         end
 
         VCR.use_cassette("upload") do
@@ -63,8 +63,8 @@ describe VCR::Middleware::Faraday do
       end
 
       # there should be no blanks
-      recorded.select { |r| r.to_s == '' }.should eq([])
-      played_back.should eq(recorded)
+      expect(recorded.select { |r| r.to_s == '' }).to eq([])
+      expect(played_back).to eq(recorded)
     end
 
     shared_examples_for "exclusive library hook" do
@@ -73,17 +73,17 @@ describe VCR::Middleware::Faraday do
       end
 
       it 'makes the faraday middleware exclusively enabled for the duration of the request' do
-        VCR.library_hooks.should_not be_disabled(:fakeweb)
+        expect(VCR.library_hooks).not_to be_disabled(:fakeweb)
 
         hook_called = false
         VCR.configuration.after_http_request do
           hook_called = true
-          VCR.library_hooks.should be_disabled(:fakeweb)
+          expect(VCR.library_hooks).to be_disabled(:fakeweb)
         end
 
         make_request
-        VCR.library_hooks.should_not be_disabled(:fakeweb)
-        hook_called.should be_true
+        expect(VCR.library_hooks).not_to be_disabled(:fakeweb)
+        expect(hook_called).to be_true
       end
     end
 
@@ -133,11 +133,11 @@ describe VCR::Middleware::Faraday do
         VCR.configuration.after_http_request { |request| VCR.eject_cassette }
 
         VCR.should_receive(:record_http_interaction) do |interaction|
-          VCR.current_cassette.should be(inserted_cassette)
+          expect(VCR.current_cassette).to be(inserted_cassette)
         end
 
         make_request
-        VCR.current_cassette.should be_nil
+        expect(VCR.current_cassette).to be_nil
       end
     end
   end if defined?(::Typhoeus)

data/spec/vcr/middleware/rack_spec.rb

@@ -6,29 +6,29 @@ module VCR
     describe CassetteArguments do
       describe '#name' do
         it 'initially returns nil' do
-          subject.name.should be_nil
+          expect(subject.name).to be_nil
         end
 
         it 'stores the given value, returning it when no arg is given' do
           subject.name :value1
-          subject.name.should eq(:value1)
+          expect(subject.name).to eq(:value1)
 
           subject.name :value2
-          subject.name.should eq(:value2)
+          expect(subject.name).to eq(:value2)
         end
       end
 
       describe '#options' do
         it 'initially returns an empty hash' do
-          subject.options.should eq({})
+          expect(subject.options).to eq({})
         end
 
         it 'merges the given hash options, returning them when no arg is given' do
           subject.options :record => :new_episodes
-          subject.options.should eq({ :record => :new_episodes })
+          expect(subject.options).to eq({ :record => :new_episodes })
 
           subject.options :erb => true
-          subject.options.should eq({ :record => :new_episodes, :erb => true })
+          expect(subject.options).to eq({ :record => :new_episodes, :erb => true })
         end
       end
     end
@@ -48,25 +48,30 @@ module VCR
           rack_app = mock
           rack_app.should_receive(:call).with(env_hash).and_return(:response)
           instance = described_class.new(rack_app) { |c| c.name 'cassette_name' }
-          instance.call(env_hash).should eq(:response)
+          expect(instance.call(env_hash)).to eq(:response)
         end
 
         it 'uses a cassette when the rack app is called' do
-          VCR.current_cassette.should be_nil
-          rack_app = lambda { |env| VCR.current_cassette.should_not be_nil }
+          expect(VCR.current_cassette).to be_nil
+          rack_app = lambda { |env| expect(VCR.current_cassette).not_to be_nil }
           instance = described_class.new(rack_app) { |c| c.name 'cassette_name' }
           instance.call({})
-          VCR.current_cassette.should be_nil
+          expect(VCR.current_cassette).to be_nil
         end
 
         it 'sets the cassette name based on the provided block' do
-          rack_app = lambda { |env| VCR.current_cassette.name.should eq('rack_cassette') }
+          rack_app = lambda do |env|
+            expect(VCR.current_cassette.name).to eq('rack_cassette')
+          end
           instance = described_class.new(rack_app) { |c| c.name 'rack_cassette' }
           instance.call({})
         end
 
         it 'sets the cassette options based on the provided block' do
-          rack_app = lambda { |env| VCR.current_cassette.erb.should eq({ :foo => :bar }) }
+          rack_app = lambda do |env|
+            expect(VCR.current_cassette.erb).to eq({ :foo => :bar })
+          end
+
           instance = described_class.new(rack_app, &lambda do |c|
             c.name    'c'
             c.options :erb => { :foo => :bar }
@@ -77,7 +82,7 @@ module VCR
 
         it 'yields the rack env to the provided block when the block accepts 2 arguments' do
           instance = described_class.new(lambda { |env| }, &lambda do |c, env|
-            env.should eq(env_hash)
+            expect(env).to eq(env_hash)
             c.name    'c'
           end)
 
@@ -88,7 +93,7 @@ module VCR
       let(:threaded_app) do
         lambda do |env|
           sleep 0.15
-          VCR.send(:cassettes).should have(1).cassette
+          expect(VCR.send(:cassettes)).to have(1).cassette
           [200, {}, ['OK']]
         end
       end
@@ -102,7 +107,7 @@ module VCR
         stack.call({})
         thread.join
 
-        VCR.current_cassette.should be_nil
+        expect(VCR.current_cassette).to be_nil
       end
     end
   end

data/spec/vcr/request_ignorer_spec.rb

@@ -9,7 +9,7 @@ module VCR
 
     shared_examples_for "#ignore?" do |url, expected_value|
       it "returns #{expected_value} if given a request with a url like #{url}" do
-        subject.ignore?(request(url)).should eq(expected_value)
+        expect(subject.ignore?(request(url))).to eq(expected_value)
       end
     end
 
@@ -58,11 +58,11 @@ module VCR
       end
 
       it 'ignores requests for which the block returns true' do
-        subject.ignore?(request('http://foo.com:5/bar')).should be_true
+        expect(subject.ignore?(request('http://foo.com:5/bar'))).to be_true
       end
 
       it 'does not ignore requests for which the block returns false' do
-        subject.ignore?(request('http://foo.com:6/bar')).should be_false
+        expect(subject.ignore?(request('http://foo.com:6/bar'))).to be_false
       end
     end
   end

data/spec/vcr/request_matcher_registry_spec.rb

@@ -21,7 +21,7 @@ module VCR
         matcher_called = false
         subject.register(:my_matcher) { |*a| matcher_called = true }
         subject[:my_matcher].matches?(stub, stub)
-        matcher_called.should be_true
+        expect(matcher_called).to be_true
       end
 
       context 'when there is already a matcher for the given name' do
@@ -32,7 +32,7 @@ module VCR
 
         it 'overrides the existing matcher' do
           subject.register(:foo) { |*a| true }
-          subject[:foo].matches?(stub, stub).should be_true
+          expect(subject[:foo].matches?(stub, stub)).to be_true
         end
 
         it 'warns that there is a name collision' do
@@ -49,7 +49,7 @@ module VCR
       it 'returns a previously registered matcher' do
         matcher = lambda { }
         subject.register(:my_matcher, &matcher)
-        subject[:my_matcher].should eq(RequestMatcherRegistry::Matcher.new(matcher))
+        expect(subject[:my_matcher]).to eq(RequestMatcherRegistry::Matcher.new(matcher))
       end
 
       it 'raises an ArgumentError when no matcher has been registered for the given name' do
@@ -60,15 +60,15 @@ module VCR
 
       it 'returns an object that calls the named block when #matches? is called on it' do
         subject.register(:foo) { |r1, r2| r1 == 5 || r2 == 10 }
-        subject[:foo].matches?(5, 0).should be_true
-        subject[:foo].matches?(0, 10).should be_true
-        subject[:foo].matches?(7, 7).should be_false
+        expect(subject[:foo].matches?(5, 0)).to be_true
+        expect(subject[:foo].matches?(0, 10)).to be_true
+        expect(subject[:foo].matches?(7, 7)).to be_false
       end
 
       it 'returns an object that calls the given callable when #matches? is called on it' do
         block_called = false
         subject[lambda { |r1, r2| block_called = true }].matches?(5, 0)
-        block_called.should be_true
+        expect(block_called).to be_true
       end
     end
 
@@ -77,80 +77,91 @@ module VCR
         it 'returns a matcher that can be registered for later use' do
           matcher = subject.send(meth, :foo)
           subject.register(:uri_without_foo, &matcher)
-          subject[:uri_without_foo].matches?(
+          matches = subject[:uri_without_foo].matches?(
             request_with(:uri => 'http://example.com/search?foo=123'),
             request_with(:uri => 'http://example.com/search?foo=123')
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
 
         it 'matches two requests with URIs that are identical' do
-          subject[subject.send(meth, :foo)].matches?(
+          matches = subject[subject.send(meth, :foo)].matches?(
             request_with(:uri => 'http://example.com/search?foo=123'),
             request_with(:uri => 'http://example.com/search?foo=123')
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
 
         it 'does not match two requests with different path parts' do
-          subject[subject.send(meth, :foo)].matches?(
+          matches = subject[subject.send(meth, :foo)].matches?(
             request_with(:uri => 'http://example.com/search?foo=123'),
             request_with(:uri => 'http://example.com/find?foo=123')
-          ).should be_false
+          )
+          expect(matches).to be_false
         end
 
         it 'ignores the given query parameters when it is at the start' do
-          subject[subject.send(meth, :foo)].matches?(
+          matches = subject[subject.send(meth, :foo)].matches?(
             request_with(:uri => 'http://example.com/search?foo=123&bar=r'),
             request_with(:uri => 'http://example.com/search?foo=124&bar=r')
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
 
         it 'ignores the given query parameters when it is at the end' do
-          subject[subject.send(meth, :bar)].matches?(
+          matches = subject[subject.send(meth, :bar)].matches?(
             request_with(:uri => 'http://example.com/search?foo=124&bar=r'),
             request_with(:uri => 'http://example.com/search?foo=124&bar=q')
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
 
         it 'still takes into account other query params' do
-          subject[subject.send(meth, :bar)].matches?(
+          matches = subject[subject.send(meth, :bar)].matches?(
             request_with(:uri => 'http://example.com/search?foo=123&bar=r'),
             request_with(:uri => 'http://example.com/search?foo=124&bar=q')
-          ).should be_false
+          )
+          expect(matches).to be_false
         end
 
         it 'handles multiple query params of the same name' do
-          subject[subject.send(meth, :tag)].matches?(
+          matches = subject[subject.send(meth, :tag)].matches?(
             request_with(:uri => 'http://example.com/search?foo=124&tag[]=a&tag[]=b'),
             request_with(:uri => 'http://example.com/search?foo=124&tag[]=d&tag[]=e')
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
 
         it 'can ignore multiple named parameters' do
-          subject[subject.send(meth, :foo, :bar)].matches?(
+          matches = subject[subject.send(meth, :foo, :bar)].matches?(
             request_with(:uri => 'http://example.com/search?foo=123&bar=r&baz=9'),
             request_with(:uri => 'http://example.com/search?foo=124&baz=9&bar=q')
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
 
         it 'matches two requests with URIs that have no params' do
-          subject[subject.send(meth, :foo, :bar)].matches?(
+          matches = subject[subject.send(meth, :foo, :bar)].matches?(
             request_with(:uri => 'http://example.com/search'),
             request_with(:uri => 'http://example.com/search')
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
 
         it 'does not match two requests with URIs that have no params but different paths' do
-          subject[subject.send(meth, :foo, :bar)].matches?(
+          matches = subject[subject.send(meth, :foo, :bar)].matches?(
             request_with(:uri => 'http://example.com/foo'),
             request_with(:uri => 'http://example.com/bar')
-          ).should be_false
+          )
+          expect(matches).to be_false
         end
 
         it 'matches a second request when all parameters are filtered' do
-          subject[subject.send(meth, :q, :oq)].matches?(
+          matches = subject[subject.send(meth, :q, :oq)].matches?(
             request_with(:uri => 'http://example.com/search'),
             request_with(:uri => 'http://example.com/search?q=vcr&oq=vcr')
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
       end
     end
@@ -158,127 +169,143 @@ module VCR
     describe "built-ins" do
       describe ":method" do
         it 'matches when it is the same' do
-          subject[:method].matches?(
+          matches = subject[:method].matches?(
             request_with(:method => :get),
             request_with(:method => :get)
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
 
         it 'does not match when it is not the same' do
-          subject[:method].matches?(
+          matches = subject[:method].matches?(
             request_with(:method => :get),
             request_with(:method => :post)
-          ).should be_false
+          )
+          expect(matches).to be_false
         end
       end
 
       describe ":uri" do
         it 'matches when it is exactly the same' do
-          subject[:uri].matches?(
+          matches = subject[:uri].matches?(
             request_with(:uri => 'http://foo.com/bar?baz=7'),
             request_with(:uri => 'http://foo.com/bar?baz=7')
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
 
         it 'does not match when it is different' do
-          subject[:uri].matches?(
+          matches = subject[:uri].matches?(
             request_with(:uri => 'http://foo1.com/bar?baz=7'),
             request_with(:uri => 'http://foo2.com/bar?baz=7')
-          ).should be_false
+          )
+          expect(matches).to be_false
         end
       end
 
       describe ":host" do
         it 'matches when it is the same' do
-          subject[:host].matches?(
+          matches = subject[:host].matches?(
             request_with(:uri => 'http://foo.com/bar'),
             request_with(:uri => 'http://foo.com/car')
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
 
         it 'does not match when it is not the same' do
-          subject[:host].matches?(
+          matches = subject[:host].matches?(
             request_with(:uri => 'http://foo.com/bar'),
             request_with(:uri => 'http://goo.com/bar')
-          ).should be_false
+          )
+          expect(matches).to be_false
         end
       end
 
       describe ":path" do
         it 'matches when it is the same' do
-          subject[:path].matches?(
+          matches = subject[:path].matches?(
             request_with(:uri => 'http://foo.com/bar?a=8'),
             request_with(:uri => 'http://goo.com/bar?a=9')
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
 
         it 'does not match when it is not the same' do
-          subject[:path].matches?(
+          matches = subject[:path].matches?(
             request_with(:uri => 'http://foo.com/bar?a=8'),
             request_with(:uri => 'http://foo.com/car?a=8')
-          ).should be_false
+          )
+          expect(matches).to be_false
         end
       end
 
       describe ":body" do
         it 'matches when it is the same' do
-          subject[:body].matches?(
+          matches = subject[:body].matches?(
             request_with(:body => 'foo'),
             request_with(:body => 'foo')
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
 
         it 'does not match when it is not the same' do
-          subject[:body].matches?(
+          matches = subject[:body].matches?(
             request_with(:body => 'foo'),
             request_with(:body => 'bar')
-          ).should be_false
+          )
+          expect(matches).to be_false
         end
       end
 
       describe ":headers" do
         it 'matches when it is the same' do
-          subject[:headers].matches?(
+          matches = subject[:headers].matches?(
             request_with(:headers => { 'a' => 1, 'b' => 2 }),
             request_with(:headers => { 'b' => 2, 'a' => 1 })
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
 
         it 'does not match when it is not the same' do
-          subject[:headers].matches?(
+          matches = subject[:headers].matches?(
             request_with(:headers => { 'a' => 3, 'b' => 2 }),
             request_with(:headers => { 'b' => 2, 'a' => 1 })
-          ).should be_false
+          )
+          expect(matches).to be_false
         end
       end
 
       describe ":query" do
         it 'matches when it is identical' do
-          subject[:query].matches?(
+          matches = subject[:query].matches?(
             request_with(:uri => 'http://foo.com/bar?a=8'),
             request_with(:uri => 'http://goo.com/car?a=8')
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
 
         it 'matches when empty' do
-          subject[:query].matches?(
+          matches = subject[:query].matches?(
             request_with(:uri => 'http://foo.com/bar'),
             request_with(:uri => 'http://goo.com/car')
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
 
         it 'matches when parameters are reordered' do
-          subject[:query].matches?(
+          matches = subject[:query].matches?(
             request_with(:uri => 'http://foo.com/bar?a=8&b=9'),
             request_with(:uri => 'http://goo.com/car?b=9&a=8')
-          ).should be_true
+          )
+          expect(matches).to be_true
         end
 
         it 'does not match when it is not the same' do
-          subject[:query].matches?(
+          matches = subject[:query].matches?(
             request_with(:uri => 'http://foo.com/bar?a=8'),
             request_with(:uri => 'http://goo.com/car?b=8')
-          ).should be_false
+          )
+          expect(matches).to be_false
         end
       end
     end