vcr 3.0.3 → 4.0.0

data/spec/lib/vcr/middleware/rack_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-require 'vcr/middleware/rack'
-
-module VCR
-  module Middleware
-    describe CassetteArguments do
-      describe '#name' do
-        it 'initially returns nil' do
-          expect(subject.name).to be_nil
-        end
-
-        it 'stores the given value, returning it when no arg is given' do
-          subject.name :value1
-          expect(subject.name).to eq(:value1)
-
-          subject.name :value2
-          expect(subject.name).to eq(:value2)
-        end
-      end
-
-      describe '#options' do
-        it 'initially returns an empty hash' do
-          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
-          expect(subject.options).to eq({ :record => :new_episodes })
-
-          subject.options :erb => true
-          expect(subject.options).to eq({ :record => :new_episodes, :erb => true })
-        end
-      end
-    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
-
-      describe '#call' do
-        let(:env_hash) { { :env => :hash } }
-        it 'calls the provided rack app and returns its response' do
-          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
-
-        it 'uses a cassette when the rack app is called' do
-          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({})
-          expect(VCR.current_cassette).to be_nil
-        end
-
-        it 'sets the cassette name based on the provided block' do
-          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 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 }
-          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|
-            expect(env).to eq(env_hash)
-            c.name    'c'
-          end)
-
-          instance.call(env_hash)
-        end
-      end
-
-      let(:threaded_app) do
-        lambda do |env|
-          sleep 0.15
-          expect(VCR.send(:cassettes).size).to eq(1)
-          [200, {}, ['OK']]
-        end
-      end
-
-      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
-
-        expect(VCR.current_cassette).to be_nil
-      end
-    end
-  end
-end
-

data/spec/lib/vcr/request_ignorer_spec.rb

@@ -1,70 +0,0 @@
-require 'vcr/structs'
-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
-        expect(subject.ignore?(request(url))).to 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
-
-    context 'when a custom ignore_request hook has been set' do
-      before(:each) do
-        subject.ignore_request do |request|
-          URI(request.uri).port == 5
-        end
-      end
-
-      it 'ignores requests for which the block returns true' do
-        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
-        expect(subject.ignore?(request('http://foo.com:6/bar'))).to be false
-      end
-    end
-  end
-end
-

data/spec/lib/vcr/request_matcher_registry_spec.rb

@@ -1,345 +0,0 @@
-require 'vcr/request_matcher_registry'
-require 'vcr/structs'
-require 'support/limited_uri'
-require 'cgi'
-require 'support/configuration_stubbing'
-
-module VCR
-  describe RequestMatcherRegistry do
-    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|
-        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?(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 }
-          allow(subject).to receive :warn
-        end
-
-        it 'overrides the existing matcher' do
-          subject.register(:foo) { |*a| true }
-          expect(subject[:foo].matches?(double, double)).to be true
-        end
-
-        it 'warns that there is a name collision' do
-          expect(subject).to 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 "#[]" do
-      it 'returns a previously registered matcher' do
-        matcher = lambda { }
-        subject.register(:my_matcher, &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
-        expect {
-          subject[:some_unregistered_matcher]
-        }.to raise_error(VCR::Errors::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 }
-        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)
-        expect(block_called).to be true
-      end
-    end
-
-    [:uri_without_param, :uri_without_params].each do |meth|
-      describe "##{meth}" do
-        it 'returns a matcher that can be registered for later use' do
-          matcher = subject.send(meth, :foo)
-          subject.register(:uri_without_foo, &matcher)
-          matches = subject[:uri_without_foo].matches?(
-            request_with(:uri => 'http://example.com/search?foo=123'),
-            request_with(:uri => 'http://example.com/search?foo=123')
-          )
-          expect(matches).to be true
-        end
-
-        it 'matches two requests with URIs that are identical' do
-          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')
-          )
-          expect(matches).to be true
-        end
-
-        it 'does not match two requests with different path parts' do
-          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')
-          )
-          expect(matches).to be false
-        end
-
-        it 'ignores the given query parameters when it is at the start' do
-          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')
-          )
-          expect(matches).to be true
-        end
-
-        it 'ignores the given query parameters when it is at the end' do
-          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')
-          )
-          expect(matches).to be true
-        end
-
-        it 'still takes into account other query params' do
-          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')
-          )
-          expect(matches).to be false
-        end
-
-        it 'handles multiple query params of the same name' do
-          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')
-          )
-          expect(matches).to be true
-        end
-
-        it 'can ignore multiple named parameters' do
-          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')
-          )
-          expect(matches).to be true
-        end
-
-        it 'matches two requests with URIs that have no params' do
-          matches = subject[subject.send(meth, :foo, :bar)].matches?(
-            request_with(:uri => 'http://example.com/search'),
-            request_with(:uri => 'http://example.com/search')
-          )
-          expect(matches).to be true
-        end
-
-        it 'does not match two requests with URIs that have no params but different paths' do
-          matches = subject[subject.send(meth, :foo, :bar)].matches?(
-            request_with(:uri => 'http://example.com/foo'),
-            request_with(:uri => 'http://example.com/bar')
-          )
-          expect(matches).to be false
-        end
-
-        it 'matches a second request when all parameters are filtered' do
-          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')
-          )
-          expect(matches).to be true
-        end
-      end
-    end
-
-    describe "built-ins" do
-      describe ":method" do
-        it 'matches when it is the same' do
-          matches = subject[:method].matches?(
-            request_with(:method => :get),
-            request_with(:method => :get)
-          )
-          expect(matches).to be true
-        end
-
-        it 'does not match when it is not the same' do
-          matches = subject[:method].matches?(
-            request_with(:method => :get),
-            request_with(:method => :post)
-          )
-          expect(matches).to be false
-        end
-      end
-
-      describe ":uri" do
-        it 'matches when it is exactly the same' do
-          matches = subject[:uri].matches?(
-            request_with(:uri => 'http://foo.com/bar?baz=7'),
-            request_with(:uri => 'http://foo.com/bar?baz=7')
-          )
-          expect(matches).to be true
-        end
-
-        it 'does not match when it is different' do
-          matches = subject[:uri].matches?(
-            request_with(:uri => 'http://foo1.com/bar?baz=7'),
-            request_with(:uri => 'http://foo2.com/bar?baz=7')
-          )
-          expect(matches).to be false
-        end
-      end
-
-      describe ":host" do
-        it 'matches when it is the same' do
-          matches = subject[:host].matches?(
-            request_with(:uri => 'http://foo.com/bar'),
-            request_with(:uri => 'http://foo.com/car')
-          )
-          expect(matches).to be true
-        end
-
-        it 'does not match when it is not the same' do
-          matches = subject[:host].matches?(
-            request_with(:uri => 'http://foo.com/bar'),
-            request_with(:uri => 'http://goo.com/bar')
-          )
-          expect(matches).to be false
-        end
-      end
-
-      describe ":path" do
-        it 'matches when it is the same' do
-          matches = subject[:path].matches?(
-            request_with(:uri => 'http://foo.com/bar?a=8'),
-            request_with(:uri => 'http://goo.com/bar?a=9')
-          )
-          expect(matches).to be true
-        end
-
-        it 'does not match when it is not the same' do
-          matches = subject[:path].matches?(
-            request_with(:uri => 'http://foo.com/bar?a=8'),
-            request_with(:uri => 'http://foo.com/car?a=8')
-          )
-          expect(matches).to be false
-        end
-      end
-
-      describe ":body" do
-        it 'matches when it is the same' do
-          matches = subject[:body].matches?(
-            request_with(:body => 'foo'),
-            request_with(:body => 'foo')
-          )
-          expect(matches).to be true
-        end
-
-        it 'does not match when it is not the same' do
-          matches = subject[:body].matches?(
-            request_with(:body => 'foo'),
-            request_with(:body => 'bar')
-          )
-          expect(matches).to be false
-        end
-      end
-
-      describe ":body_as_json" do
-        it 'matches when the body json is reordered' do
-          matches = subject[:body_as_json].matches?(
-            request_with(:body => '{ "a": "1", "b": "2" }'),
-            request_with(:body => '{ "b": "2", "a": "1" }')
-          )
-          expect(matches).to be true
-        end
-
-        it 'does not match when json is not the same' do
-          matches = subject[:body_as_json].matches?(
-            request_with(:body => '{ "a": "1", "b": "2" }'),
-            request_with(:body => '{ "a": "1", "b": "1" }')
-          )
-          expect(matches).to be false
-        end
-
-        it 'does not match when body is not json' do
-          matches = subject[:body_as_json].matches?(
-            request_with(:body => 'a=b'),
-            request_with(:body => 'a=b')
-          )
-          expect(matches).to be false
-        end
-      end
-
-      describe ":headers" do
-        it 'matches when it is the same' do
-          matches = subject[:headers].matches?(
-            request_with(:headers => { 'a' => 1, 'b' => 2 }),
-            request_with(:headers => { 'b' => 2, 'a' => 1 })
-          )
-          expect(matches).to be true
-        end
-
-        it 'does not match when it is not the same' do
-          matches = subject[:headers].matches?(
-            request_with(:headers => { 'a' => 3, 'b' => 2 }),
-            request_with(:headers => { 'b' => 2, 'a' => 1 })
-          )
-          expect(matches).to be false
-        end
-      end
-
-      describe ":query" do
-        it 'matches when it is identical' do
-          matches = subject[:query].matches?(
-            request_with(:uri => 'http://foo.com/bar?a=8'),
-            request_with(:uri => 'http://goo.com/car?a=8')
-          )
-          expect(matches).to be true
-        end
-
-        it 'matches when empty' do
-          matches = subject[:query].matches?(
-            request_with(:uri => 'http://foo.com/bar'),
-            request_with(:uri => 'http://goo.com/car')
-          )
-          expect(matches).to be true
-        end
-
-        it 'matches when parameters are reordered' do
-          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')
-          )
-          expect(matches).to be true
-        end
-
-        it 'does not match when it is not the same' do
-          matches = subject[:query].matches?(
-            request_with(:uri => 'http://foo.com/bar?a=8'),
-            request_with(:uri => 'http://goo.com/car?b=8')
-          )
-          expect(matches).to be false
-        end
-      end
-    end
-  end
-end
-