vcr 1.11.3 → 2.0.0.beta1

data/spec/vcr/middleware/faraday_spec.rb

@@ -1,52 +1,25 @@
 require 'spec_helper'
 
 describe VCR::Middleware::Faraday do
-  describe '.new' do
-    it 'raises an error if no cassette arguments block is provided' do
-      expect {
-        described_class.new(lambda { |env| })
-      }.to raise_error(ArgumentError)
-    end
+  %w[ typhoeus net_http patron ].each do |lib|
+    it_behaves_like 'a hook into an HTTP library', "faraday (w/ #{lib})",
+      :status_message_not_exposed,
+      :does_not_support_rotating_responses,
+      :not_disableable
   end
 
-  describe '#call' do
-    let(:env_hash) { { :url => 'http://localhost:3000/' } }
-
-    before(:each) do
-      VCR::HttpStubbingAdapters::Faraday.ignored_hosts = ['localhost']
-    end
-
-    it 'uses a cassette when the app is called' do
-      VCR.current_cassette.should be_nil
-      app = lambda { |env| VCR.current_cassette.should_not be_nil }
-      instance = described_class.new(app) { |c| c.name 'cassette_name' }
-      instance.call(env_hash)
-      VCR.current_cassette.should be_nil
-    end
-
-    it 'sets the cassette name based on the provided block' do
-      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 eq({ :foo => :bar }) }
-      instance = described_class.new(app, &lambda do |c|
-        c.name    'c'
-        c.options :erb => { :foo => :bar }
-      end)
-
-      instance.call(env_hash)
-    end
-
-    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 eq(env_hash)
-        c.name    'c'
-      end)
-
-      instance.call(env_hash)
+  it_performs('version checking', 'Faraday',
+    :valid    => %w[ 0.7.0 0.7.10 ],
+    :too_low  => %w[ 0.6.9 0.5.99 ],
+    :too_high => %w[ 0.8.0 1.0.0 ],
+    :file     => 'vcr/middleware/faraday.rb'
+  ) do
+    before(:each) { @orig_version = Faraday::VERSION }
+    after(:each)  { Faraday::VERSION = @orig_version }
+
+    # Cannot be regular method def as that raises a "dynamic constant assignment" error
+    define_method :stub_version do |version|
+      ::Faraday::VERSION = version
     end
   end
 end

data/spec/vcr/middleware/rack_spec.rb

@@ -1,74 +1,110 @@
 require 'spec_helper'
+require 'vcr/middleware/rack'
 
-describe VCR::Middleware::Rack do
-  describe '.new' do
-    it 'raises an error if no cassette arguments block is provided' do
-      expect {
-        described_class.new(lambda { |env| })
-      }.to raise_error(ArgumentError)
-    end
-  end
+module VCR
+  module Middleware
+    describe CassetteArguments do
+      describe '#name' do
+        it 'initially returns nil' do
+          subject.name.should be_nil
+        end
 
-  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)
-      instance = described_class.new(rack_app) { |c| c.name 'cassette_name' }
-      instance.call(env_hash).should eq(:response)
-    end
+        it 'stores the given value, returning it when no arg is given' do
+          subject.name :value1
+          subject.name.should eq(:value1)
 
-    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 }
-      instance = described_class.new(rack_app) { |c| c.name 'cassette_name' }
-      instance.call({})
-      VCR.current_cassette.should be_nil
-    end
+          subject.name :value2
+          subject.name.should eq(:value2)
+        end
+      end
 
-    it 'sets the cassette name based on the provided block' do
-      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
+      describe '#options' do
+        it 'initially returns an empty hash' do
+          subject.options.should eq({})
+        end
 
-    it 'sets the cassette options based on the provided block' do
-      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 }
-      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 })
 
-      instance.call({})
+          subject.options :erb => true
+          subject.options.should eq({ :record => :new_episodes, :erb => true })
+        end
+      end
     end
 
-    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)
-        c.name    'c'
-      end)
+    describe Rack do
+      describe '.new' do
+        it 'raises an error if no cassette arguments block is provided' do
+          expect {
+            described_class.new(lambda { |env| })
+          }.to raise_error(ArgumentError)
+        end
+      end
 
-      instance.call(env_hash)
-    end
-  end
+      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)
+          instance = described_class.new(rack_app) { |c| c.name 'cassette_name' }
+          instance.call(env_hash).should eq(:response)
+        end
 
-  let(:threaded_app) do
-    lambda do |env|
-      sleep 0.15
-      VCR.send(:cassettes).should have(1).cassette
-      [200, {}, ['OK']]
-    end
-  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 }
+          instance = described_class.new(rack_app) { |c| c.name 'cassette_name' }
+          instance.call({})
+          VCR.current_cassette.should be_nil
+        end
 
-  it 'is thread safe' do
-    stack = described_class.new(threaded_app) do |cassette|
-      cassette.name 'c'
-    end
+        it 'sets the cassette name based on the provided block' do
+          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 eq({ :foo => :bar }) }
+          instance = described_class.new(rack_app, &lambda do |c|
+            c.name    'c'
+            c.options :erb => { :foo => :bar }
+          end)
+
+          instance.call({})
+        end
+
+        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)
+            c.name    'c'
+          end)
+
+          instance.call(env_hash)
+        end
+      end
 
-    thread = Thread.new { stack.call({}) }
-    stack.call({})
-    thread.join
+      let(:threaded_app) do
+        lambda do |env|
+          sleep 0.15
+          VCR.send(:cassettes).should have(1).cassette
+          [200, {}, ['OK']]
+        end
+      end
 
-    VCR.current_cassette.should be_nil
+      it 'is thread safe' do
+        stack = described_class.new(threaded_app) do |cassette|
+          cassette.name 'c'
+        end
+
+        thread = Thread.new { stack.call({}) }
+        stack.call({})
+        thread.join
+
+        VCR.current_cassette.should be_nil
+      end
+    end
   end
 end
+

data/spec/vcr/request_ignorer_spec.rb

@@ -0,0 +1,54 @@
+require 'vcr/structs/http_interaction'
+require 'vcr/request_ignorer'
+
+module VCR
+  describe RequestIgnorer do
+    def request(uri)
+      VCR::Request.new.tap { |r| r.uri = uri }
+    end
+
+    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)
+      end
+    end
+
+    context 'when example.com and example.net are ignored' do
+      before(:each) { subject.ignore_hosts 'example.com', 'example.net' }
+
+      it_behaves_like "#ignore?", "http://www.example.com/foo", false
+      it_behaves_like "#ignore?", "http://example.com/foo", true
+      it_behaves_like "#ignore?", "http://example.net:890/foo", true
+      it_behaves_like "#ignore?", "http://some-other-domain.com/", false
+    end
+
+    context 'when ignore_localhost is set to true' do
+      before(:each) { subject.ignore_localhost = true }
+
+      it_behaves_like "#ignore?", "http://some-host.com/foo", false
+      RequestIgnorer::LOCALHOST_ALIASES.each do |host|
+        it_behaves_like "#ignore?", "http://#{host}/foo", true
+      end
+    end
+
+    context 'when ignore_localhost is not set' do
+      it_behaves_like "#ignore?", "http://some-host.com/foo", false
+      RequestIgnorer::LOCALHOST_ALIASES.each do |host|
+        it_behaves_like "#ignore?", "http://#{host}/foo", false
+      end
+    end
+
+    context 'when ignore_localhost is set to false after being set to true' do
+      before(:each) do
+        subject.ignore_localhost = true
+        subject.ignore_localhost = false
+      end
+
+      it_behaves_like "#ignore?", "http://some-host.com/foo", false
+      RequestIgnorer::LOCALHOST_ALIASES.each do |host|
+        it_behaves_like "#ignore?", "http://#{host}/foo", false
+      end
+    end
+  end
+end
+

data/spec/vcr/request_matcher_registry_spec.rb

@@ -0,0 +1,223 @@
+require 'vcr/request_matcher_registry'
+require 'vcr/structs/http_interaction'
+require 'uri'
+
+module VCR
+  describe RequestMatcherRegistry do
+    def request_with(values)
+      VCR::Request.new.tap do |request|
+        values.each do |name, value|
+          request.send("#{name}=", value)
+        end
+      end
+    end
+
+    describe "#register" do
+      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)
+        matcher_called.should 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
+        end
+
+        it 'overrides the existing matcher' do
+          subject.register(:foo) { |*a| true }
+          subject[:foo].matches?(stub, stub).should be_true
+        end
+
+        it 'warns that there is a name collision' do
+          subject.should_receive(:warn).with(
+            /WARNING: There is already a VCR request matcher registered for :foo\. Overriding it/
+          )
+
+          subject.register(:foo) { |*a| true }
+        end
+      end
+    end
+
+    describe "#for" do
+      it 'returns a previously registered matcher' do
+        matcher = lambda { }
+        subject.register(:my_matcher, &matcher)
+        subject[:my_matcher].should eq(RequestMatcherRegistry::Matcher.new(matcher))
+      end
+
+      it 'raises an ArgumentError when no matcher has been registered for the given name' do
+        expect {
+          subject[:some_unregistered_matcher]
+        }.to raise_error(UnregisteredMatcherError)
+      end
+
+      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
+      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
+      end
+    end
+
+    [:uri_without_param, :uri_without_params].each do |meth|
+      describe "##{meth}" do
+        it 'matches two requests with URIs that are identical' do
+          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
+        end
+
+        it 'does not matches two requests with different path parts' do
+          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
+        end
+
+        it 'ignores the given query parameters when it is at the start' do
+          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
+        end
+
+        it 'ignores the given query parameters when it is at the end' do
+          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
+        end
+
+        it 'still takes into account other query params' do
+          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
+        end
+
+        it 'handles multiple query params of the same name' do
+          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
+        end
+
+        it 'can ignore multiple named parameters' do
+          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
+        end
+      end
+    end
+
+    describe "built-ins" do
+      describe ":method" do
+        it 'matches when it is the same' do
+          subject[:method].matches?(
+            request_with(:method => :get),
+            request_with(:method => :get)
+          ).should be_true
+        end
+
+        it 'does not match when it is not the same' do
+          subject[:method].matches?(
+            request_with(:method => :get),
+            request_with(:method => :post)
+          ).should be_false
+        end
+      end
+
+      describe ":uri" do
+        it 'matches when it is exactly the same' do
+          subject[:uri].matches?(
+            request_with(:uri => 'http://foo.com/bar?baz=7'),
+            request_with(:uri => 'http://foo.com/bar?baz=7')
+          ).should be_true
+        end
+
+        it 'does not match when it is different' do
+          subject[:uri].matches?(
+            request_with(:uri => 'http://foo1.com/bar?baz=7'),
+            request_with(:uri => 'http://foo2.com/bar?baz=7')
+          ).should be_false
+        end
+      end
+
+      describe ":host" do
+        it 'matches when it is the same' do
+          subject[:host].matches?(
+            request_with(:uri => 'http://foo.com/bar'),
+            request_with(:uri => 'http://foo.com/car')
+          ).should be_true
+        end
+
+        it 'does not match when it is not the same' do
+          subject[:host].matches?(
+            request_with(:uri => 'http://foo.com/bar'),
+            request_with(:uri => 'http://goo.com/bar')
+          ).should be_false
+        end
+      end
+
+      describe ":path" do
+        it 'matches when it is the same' do
+          subject[:path].matches?(
+            request_with(:uri => 'http://foo.com/bar?a=8'),
+            request_with(:uri => 'http://goo.com/bar?a=9')
+          ).should be_true
+        end
+
+        it 'does not match when it is not the same' do
+          subject[:path].matches?(
+            request_with(:uri => 'http://foo.com/bar?a=8'),
+            request_with(:uri => 'http://foo.com/car?a=8')
+          ).should be_false
+        end
+      end
+
+      describe ":body" do
+        it 'matches when it is the same' do
+          subject[:body].matches?(
+            request_with(:body => 'foo'),
+            request_with(:body => 'foo')
+          ).should be_true
+        end
+
+        it 'does not match when it is not the same' do
+          subject[:body].matches?(
+            request_with(:body => 'foo'),
+            request_with(:body => 'bar')
+          ).should be_false
+        end
+      end
+
+      describe ":headers" do
+        it 'matches when it is the same' do
+          subject[:headers].matches?(
+            request_with(:headers => { 'a' => 1, 'b' => 2 }),
+            request_with(:headers => { 'b' => 2, 'a' => 1 })
+          ).should be_true
+        end
+
+        it 'does not match when it is not the same' do
+          subject[:headers].matches?(
+            request_with(:headers => { 'a' => 3, 'b' => 2 }),
+            request_with(:headers => { 'b' => 2, 'a' => 1 })
+          ).should be_false
+        end
+      end
+    end
+  end
+end
+