vcr 1.11.1 → 1.11.2

data/spec/vcr/http_stubbing_adapters/excon_spec.rb

@@ -31,8 +31,8 @@ describe VCR::HttpStubbingAdapters::Excon do
         end
       end
 
-      recorded.should == played_back
-      recorded.should == 'query: Tolkien'
+      recorded.should eq(played_back)
+      recorded.should eq('query: Tolkien')
     end
   end
 
@@ -51,8 +51,8 @@ describe VCR::HttpStubbingAdapters::Excon do
         chunks.join
       end
 
-      recorded.should == played_back
-      recorded.should == "FOO!"
+      recorded.should eq(played_back)
+      recorded.should eq("FOO!")
     end
   end
 
@@ -61,7 +61,7 @@ describe VCR::HttpStubbingAdapters::Excon do
       described_class.http_connections_allowed = true
 
       VCR.should_receive(:record_http_interaction) do |interaction|
-        interaction.response.status.code.should == 404
+        interaction.response.status.code.should eq(404)
       end
 
       expect {

data/spec/vcr/http_stubbing_adapters/faraday_spec.rb

@@ -40,10 +40,10 @@ describe VCR::HttpStubbingAdapters::Faraday do
     end
 
     def test_stubbed_responses
-      stubbed_response_for(request_1).should == :response_1
-      stubbed_response_for(request_1).should == :response_2
-      stubbed_response_for(request_1).should == :response_2
-      stubbed_response_for(request_1).should == :response_2
+      stubbed_response_for(request_1).should eq(:response_1)
+      stubbed_response_for(request_1).should eq(:response_2)
+      stubbed_response_for(request_1).should eq(:response_2)
+      stubbed_response_for(request_1).should eq(:response_2)
     end
 
     describe '.stubbed_response_for' do

data/spec/vcr/http_stubbing_adapters/multi_object_proxy_spec.rb

@@ -17,12 +17,12 @@ module VCR
 
       it 'is a basic object with very few of its own methods' do
         inst_methods = described_class.instance_methods.map { |m| m.to_sym }
-        inst_methods.should_not include(:send, :object_id, :__id__)
+        inst_methods.should_not include(:send, :object_id)
       end
 
       describe '#proxied_objects' do
         it 'returns the proxied objects' do
-          subject.proxied_objects.should == [mock1, mock2]
+          subject.proxied_objects.should eq([mock1, mock2])
         end
       end
 
@@ -51,7 +51,7 @@ module VCR
           mock1.should_not respond_to(:request_stubbed?)
           mock2.should_receive(:request_stubbed?).and_return(true)
 
-          subject.request_stubbed?.should == true
+          subject.request_stubbed?.should eq(true)
         end
 
         it 'proxies messages to each object' do
@@ -74,7 +74,7 @@ module VCR
               mock1.should_receive(method).and_return(:return_value_1)
               mock2.should_receive(method).and_return(:return_value_1)
 
-              subject.__send__(method).should == :return_value_1
+              subject.__send__(method).should eq(:return_value_1)
             end
           end
         end

data/spec/vcr/middleware/cassette_arguments_spec.rb

@@ -8,24 +8,24 @@ describe VCR::Middleware::CassetteArguments do
 
     it 'stores the given value, returning it when no arg is given' do
       subject.name :value1
-      subject.name.should == :value1
+      subject.name.should eq(:value1)
 
       subject.name :value2
-      subject.name.should == :value2
+      subject.name.should eq(:value2)
     end
   end
 
   describe '#options' do
     it 'initially returns an empty hash' do
-      subject.options.should == {}
+      subject.options.should eq({})
     end
 
     it 'merges the given hash options, returning them when no arg is given' do
       subject.options :record => :new_episodes
-      subject.options.should == { :record => :new_episodes }
+      subject.options.should eq({ :record => :new_episodes })
 
       subject.options :erb => true
-      subject.options.should == { :record => :new_episodes, :erb => true }
+      subject.options.should eq({ :record => :new_episodes, :erb => true })
     end
   end
 end

data/spec/vcr/middleware/faraday_spec.rb

@@ -25,13 +25,13 @@ describe VCR::Middleware::Faraday do
     end
 
     it 'sets the cassette name based on the provided block' do
-      app = lambda { |env| VCR.current_cassette.name.should == 'rack_cassette' }
+      app = lambda { |env| VCR.current_cassette.name.should eq('rack_cassette') }
       instance = described_class.new(app) { |c| c.name 'rack_cassette' }
       instance.call(env_hash)
     end
 
     it 'sets the cassette options based on the provided block' do
-      app = lambda { |env| VCR.current_cassette.erb.should == { :foo => :bar } }
+      app = lambda { |env| VCR.current_cassette.erb.should eq({ :foo => :bar }) }
       instance = described_class.new(app, &lambda do |c|
         c.name    'c'
         c.options :erb => { :foo => :bar }
@@ -42,7 +42,7 @@ describe VCR::Middleware::Faraday do
 
     it 'yields the env to the provided block when the block accepts 2 arguments' do
       instance = described_class.new(lambda { |env| }, &lambda do |c, env|
-        env.should == env_hash
+        env.should eq(env_hash)
         c.name    'c'
       end)
 

data/spec/vcr/middleware/rack_spec.rb

@@ -15,7 +15,7 @@ describe VCR::Middleware::Rack do
       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 == :response
+      instance.call(env_hash).should eq(:response)
     end
 
     it 'uses a cassette when the rack app is called' do
@@ -27,13 +27,13 @@ describe VCR::Middleware::Rack do
     end
 
     it 'sets the cassette name based on the provided block' do
-      rack_app = lambda { |env| VCR.current_cassette.name.should == 'rack_cassette' }
+      rack_app = lambda { |env| VCR.current_cassette.name.should eq('rack_cassette') }
       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 == { :foo => :bar } }
+      rack_app = lambda { |env| VCR.current_cassette.erb.should eq({ :foo => :bar }) }
       instance = described_class.new(rack_app, &lambda do |c|
         c.name    'c'
         c.options :erb => { :foo => :bar }
@@ -44,7 +44,7 @@ describe VCR::Middleware::Rack do
 
     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 == env_hash
+        env.should eq(env_hash)
         c.name    'c'
       end)
 

data/spec/vcr/request_matcher_spec.rb

@@ -10,7 +10,7 @@ describe VCR::RequestMatcher do
   describe '#uri' do
     def self.for_matcher(*attributes, &block)
       context "for match_attributes = #{attributes.inspect}" do
-        subject { matcher = VCR::RequestMatcher.new(stub(:uri => uri), attributes).uri }
+        subject { VCR::RequestMatcher.new(stub(:uri => uri), attributes).uri }
         module_eval(&block)
       end
     end
@@ -18,11 +18,11 @@ describe VCR::RequestMatcher do
     let(:uri) { 'http://foo.example.com/path/to/something?param=value' }
 
     for_matcher do
-      it("returns a regex that matches any URI") { should == /.*/ }
+      it("returns a regex that matches any URI") { should eq(/.*/) }
     end
 
     for_matcher :uri do
-      it("returns the exact uri") { should == uri }
+      it("returns the exact uri") { should eq(uri) }
     end
 
     for_matcher :host do
@@ -73,7 +73,7 @@ describe VCR::RequestMatcher do
     end
 
     [[:uri, :host], [:uri, :path], [:uri, :host, :path]].each do |attributes|
-      for_matcher *attributes do
+      for_matcher(*attributes) do
         it "raises an appropriate error" do
           expect { subject }.to raise_error(/match_attributes cannot include/)
         end
@@ -83,7 +83,7 @@ describe VCR::RequestMatcher do
     it "returns the request's URI when it is a regex, regardless of the match attributes" do
       [:uri, :host, :path].each do |attribute|
         matcher = VCR::RequestMatcher.new(stub(:uri => /some regex/), [attribute])
-        matcher.uri.should == /some regex/
+        matcher.uri.should eq(/some regex/)
       end
     end
   end
@@ -91,7 +91,7 @@ describe VCR::RequestMatcher do
   describe '#method' do
     it 'returns the request method when the match attributes include :method' do
       matcher = VCR::RequestMatcher.new(stub(:method => :get), [:method])
-      matcher.method.should == :get
+      matcher.method.should eq(:get)
     end
 
     it 'returns nil when the match attributes do not include :method' do
@@ -103,7 +103,7 @@ describe VCR::RequestMatcher do
   describe '#body' do
     it 'returns the request body when the match attributes include :body' do
       matcher = VCR::RequestMatcher.new(stub(:body => 'id=7'), [:body])
-      matcher.body.should == 'id=7'
+      matcher.body.should eq('id=7')
     end
 
     it 'returns nil when the match attributes do not include :body' do
@@ -115,7 +115,7 @@ describe VCR::RequestMatcher do
   describe '#headers' do
     it 'returns the request headers when the match attributes include :headers' do
       matcher = VCR::RequestMatcher.new(stub(:headers => { 'key' => 'value' }), [:headers])
-      matcher.headers.should == { 'key' => 'value' }
+      matcher.headers.should eq({ 'key' => 'value' })
     end
 
     it 'returns nil when the match attributes do not include :headers' do
@@ -152,14 +152,14 @@ describe VCR::RequestMatcher do
   describe '#hash' do
     it 'returns the same code for two objects when #match_attributes, #method, #uri, #body and #headers are the same, even when the request object is different' do
       m1, m2 = matchers_varying_on(:request)
-      m1.hash.should == m2.hash
+      m1.hash.should eq(m2.hash)
     end
 
     it 'returns the same code for two objects when the matchers are the same, but #match_attributes has its elements in a different order' do
       m1, m2 = matcher, matcher
       m1.match_attributes = [:method, :uri, :body, :headers]
       m2.match_attributes = [:method, :body, :uri, :headers]
-      m1.hash.should == m2.hash
+      m1.hash.should eq(m2.hash)
     end
 
     [:match_attributes, :method, :uri, :body, :headers].each do |different_attr|
@@ -173,19 +173,19 @@ describe VCR::RequestMatcher do
       it 'returns the same code for the same headers' do
         m1 = matcher_with_headers('x-http-header' => ['val1'])
         m2 = matcher_with_headers('x-http-header' => ['val1'])
-        m1.hash.should == m2.hash
+        m1.hash.should eq(m2.hash)
       end
 
       it 'returns the same code when the header keys are ordered differently' do
         m1 = matcher_with_headers('x-http-header1' => ['val1'], 'x-http-header2' => ['val2'])
         m2 = matcher_with_headers('x-http-header2' => ['val2'], 'x-http-header1' => ['val1'])
-        m1.hash.should == m2.hash
+        m1.hash.should eq(m2.hash)
       end
 
       it 'returns the same code when the header value arrays are ordered differently' do
         m1 = matcher_with_headers('x-http-header' => ['val1', 'val2'])
         m2 = matcher_with_headers('x-http-header' => ['val2', 'val1'])
-        m1.hash.should == m2.hash
+        m1.hash.should eq(m2.hash)
       end
 
       it 'returns a different code when the header values are different' do

data/spec/vcr/structs/http_interaction_spec.rb

@@ -6,7 +6,7 @@ describe VCR::HTTPInteraction do
       sig = mock('request signature')
       sig.should_receive(attr).and_return(:the_value)
       instance = described_class.new(sig, nil)
-      instance.send(attr).should == :the_value
+      instance.send(attr).should eq(:the_value)
     end
   end
 
@@ -62,23 +62,23 @@ describe VCR::HTTPInteraction do
 
     [:request, :response].each do |part|
       it "replaces the sensitive text in the #{part} header keys and values" do
-        subject.send(part).headers.should == {
+        subject.send(part).headers.should eq({
           'x-http-AAA' => ['bar23', '23AAA'],
           'x-http-bar' => ['AAA23', '18']
-        }
+        })
       end
 
       it "replaces the sensitive text in the #{part} body" do
-        subject.send(part).body.should == "The body AAA this is (AAA-Foo)"
+        subject.send(part).body.should eq("The body AAA this is (AAA-Foo)")
       end
     end
 
     it 'replaces the sensitive text in the response status' do
-      subject.response.status.message.should == 'OK AAA'
+      subject.response.status.message.should eq('OK AAA')
     end
 
     it 'replaces sensitive text in the request URI' do
-      subject.request.uri.should == 'http://example-AAA.com:80/AAA/'
+      subject.request.uri.should eq('http://example-AAA.com:80/AAA/')
     end
   end
 end

data/spec/vcr/structs/request_spec.rb

@@ -4,7 +4,7 @@ describe VCR::Request do
   describe '#matcher' do
     it 'returns a matcher with the given request' do
       req = VCR::Request.new
-      req.matcher([:uri]).request.should == req
+      req.matcher([:uri]).request.should eq(req)
     end
 
     it 'returns a matcher with the given match_attributes' do
@@ -18,7 +18,7 @@ describe VCR::Request do
 
     context 'when given no arguments' do
       it 'returns the HTTP method' do
-        subject.method.should == :get
+        subject.method.should eq(:get)
       end
     end
 
@@ -26,7 +26,7 @@ describe VCR::Request do
       it 'returns the method object for the named method' do
         m = subject.method(:class)
         m.should be_a(Method)
-        m.call.should == described_class
+        m.call.should eq(described_class)
       end
     end
   end
@@ -42,13 +42,13 @@ describe VCR::Request do
     end
 
     it            { should be_instance_of(VCR::Request) }
-    its(:method)  { should == :post  }
-    its(:body)    { should == 'id=7'  }
-    its(:headers) { should == { "content-type" => ["application/x-www-form-urlencoded"] } }
+    its(:method)  { should eq(:post) }
+    its(:body)    { should eq('id=7') }
+    its(:headers) { should eq({ "content-type" => ["application/x-www-form-urlencoded"] }) }
 
     it 'sets the uri using the http_stubbing_adapter.request_uri' do
       VCR.http_stubbing_adapter.should_receive(:request_uri).with(net_http, request).and_return('foo/bar')
-      subject.uri.should == 'foo/bar'
+      subject.uri.should eq('foo/bar')
     end
   end
 

data/spec/vcr/structs/response_spec.rb

@@ -6,9 +6,9 @@ describe VCR::Response do
     subject { described_class.from_net_http_response(response) }
 
     it                 { should be_instance_of(described_class) }
-    its(:body)         { should == 'The response from example.com' }
-    its(:http_version) { should == '1.1' }
-    its(:headers)      { should == {
+    its(:body)         { should eq('The response from example.com') }
+    its(:http_version) { should eq('1.1') }
+    its(:headers)      { should eq({
       "last-modified"  => ['Tue, 15 Nov 2005 13:24:10 GMT'],
       "etag"           => ["\"24ec5-1b6-4059a80bfd280\""],
       "content-type"   => ["text/html; charset=UTF-8"],
@@ -16,12 +16,12 @@ describe VCR::Response do
       "server"         => ['Apache/2.2.3 (CentOS)'],
       "content-length" => ['438'],
       "accept-ranges"  => ['bytes']
-    } }
+    }) }
 
     it 'assigns the status using VCR::ResponseStatus.from_net_http_response' do
       VCR::ResponseStatus.should respond_to(:from_net_http_response)
       VCR::ResponseStatus.should_receive(:from_net_http_response).with(response).and_return(:the_status)
-      subject.status.should == :the_status
+      subject.status.should eq(:the_status)
     end
   end
 

data/spec/vcr/structs/response_status_spec.rb

@@ -6,8 +6,8 @@ describe VCR::ResponseStatus do
     subject { described_class.from_net_http_response(response) }
 
     it            { should be_instance_of(described_class) }
-    its(:code)    { should == 200 }
-    its(:message) { should == 'OK' }
+    its(:code)    { should eq(200) }
+    its(:message) { should eq('OK') }
   end
 
   it_performs 'status message normalization' do

data/spec/vcr/test_frameworks/cucumber_spec.rb

@@ -18,7 +18,7 @@ describe VCR::CucumberTags do
     VCR.current_cassette.should be_nil
 
     before_blocks_for_tags[tag].call
-    VCR.current_cassette.send(cassette_attribute).should == expected_value
+    VCR.current_cassette.send(cassette_attribute).should eq(expected_value)
     after_blocks_for_tags[tag].call
 
     VCR.current_cassette.should be_nil
@@ -54,7 +54,7 @@ describe VCR::CucumberTags do
     it 'returns the list of cucumber tags' do
       subject.tags 'tag1', 'tag2'
       subject.tags 'tag3', 'tag4'
-      described_class.tags[-4, 4].should == %w(@tag1 @tag2 @tag3 @tag4)
+      described_class.tags[-4, 4].should eq(%w(@tag1 @tag2 @tag3 @tag4))
     end
   end
 end

data/spec/vcr/test_frameworks/rspec_spec.rb

@@ -7,20 +7,19 @@ describe VCR::RSpec::Macros do
     def self.perform_test(context_name, expected_cassette_name, *args, &block)
       context context_name do
         after(:each) do
-          if @test_ejection
+          if example.metadata[:test_ejection]
             VCR.current_cassette.should be_nil
           end
         end
 
-        use_vcr_cassette *args
+        use_vcr_cassette(*args)
 
-        it 'ejects the cassette in an after hook' do
+        it 'ejects the cassette in an after hook', :test_ejection do
           VCR.current_cassette.should be_a(VCR::Cassette)
-          @test_ejection = true
         end
 
         it "creates a cassette named '#{expected_cassette_name}" do
-          VCR.current_cassette.name.should == expected_cassette_name
+          VCR.current_cassette.name.should eq(expected_cassette_name)
         end
 
         module_eval(&block) if block
@@ -31,7 +30,7 @@ describe VCR::RSpec::Macros do
 
     perform_test 'when called with an explicit name and some options', 'explicit_name', 'explicit_name', :match_requests_on => [:method, :host] do
       it 'uses the provided cassette options' do
-        VCR.current_cassette.match_requests_on.should == [:method, :host]
+        VCR.current_cassette.match_requests_on.should eq([:method, :host])
       end
     end
 
@@ -39,7 +38,7 @@ describe VCR::RSpec::Macros do
 
     perform_test 'when called with some options', 'VCR::RSpec::Macros/#use_vcr_cassette/when called with some options', :match_requests_on => [:method, :host] do
       it 'uses the provided cassette options' do
-        VCR.current_cassette.match_requests_on.should == [:method, :host]
+        VCR.current_cassette.match_requests_on.should eq([:method, :host])
       end
     end
   end