vcr 3.0.3 → 6.1.0

data/spec/lib/vcr/library_hooks_spec.rb

@@ -1,51 +0,0 @@
-require 'vcr/library_hooks'
-
-module VCR
-  describe LibraryHooks do
-    describe '#disabled?' do
-      it 'returns false by default for any argument given' do
-        expect(subject.disabled?(:foo)).to be false
-        expect(subject.disabled?(:bar)).to be false
-      end
-
-      context 'when a library hook is exclusively enabled' do
-        it 'returns false for the exclusively enabled hook' do
-          faraday_disabled = nil
-
-          subject.exclusively_enabled :faraday do
-            faraday_disabled = subject.disabled?(:faraday)
-          end
-
-          expect(faraday_disabled).to eq(false)
-        end
-
-        it 'returns true for every other argument given' do
-          foo_disabled = bar_disabled = nil
-
-          subject.exclusively_enabled :faraday do
-            foo_disabled = subject.disabled?(:foo)
-            bar_disabled = subject.disabled?(:bar)
-          end
-
-          expect(foo_disabled).to be true
-          expect(bar_disabled).to be true
-        end
-      end
-    end
-
-    describe '#exclusively_enabled' do
-      it 'restores all hook to being enabled when the block completes' do
-        subject.exclusively_enabled(:faraday) { }
-        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
-        expect(subject.disabled?(:foo)).to be false
-        expect(subject.disabled?(:faraday)).to be false
-      end
-    end
-  end
-end
-

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

@@ -1,181 +0,0 @@
-require 'spec_helper'
-require 'vcr/library_hooks/faraday'
-
-describe VCR::Middleware::Faraday do
-  http_libs = %w[ typhoeus net_http patron ]
-  http_libs.each do |lib|
-    it_behaves_like 'a hook into an HTTP library', :faraday, "faraday (w/ #{lib})",
-      :status_message_not_exposed,
-      :does_not_support_rotating_responses
-  end
-
-  context 'when performing a multipart upload' do
-    let(:connection) do
-      ::Faraday.new("http://localhost:#{VCR::SinatraApp.port}/") do |b|
-        b.request :multipart
-      end
-    end
-
-    def self.test_recording
-      it 'records the request body correctly' do
-        payload = { :file => Faraday::UploadIO.new(__FILE__, 'text/plain') }
-
-        expect(VCR).to receive(:record_http_interaction) do |i|
-          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
-          connection.post '/files', payload
-        end
-      end
-    end
-
-    context 'when the net_http adapter is used' do
-      before { connection.builder.adapter :net_http }
-      test_recording
-    end
-
-    context 'when no adapter is used' do
-      test_recording
-    end
-  end
-
-  context 'when extending the response body with an extension module' do
-    let(:connection) { ::Faraday.new("http://localhost:#{VCR::SinatraApp.port}/") }
-
-    def process_response(response)
-      response.body.extend Module.new { attr_accessor :_response }
-      response.body._response = response
-    end
-
-    it 'does not record the body extensions to the cassette' do
-      3.times do |i|
-        VCR.use_cassette("hack", :record => :new_episodes) do
-          response = connection.get("/foo")
-          process_response(response)
-
-          # Do something different after the first time to
-          # ensure new interactions are added to an existing
-          # cassette.
-          if i > 1
-            response = connection.get("/")
-            process_response(response)
-          end
-        end
-      end
-
-      contents = VCR::Cassette.new("hack").send(:raw_cassette_bytes)
-      expect(contents).not_to include("ruby/object:Faraday::Response")
-    end
-  end
-
-  context 'when making parallel requests' do
-    include VCRStubHelpers
-    let(:connection)         { ::Faraday.new { |b| b.adapter :typhoeus } }
-    let(:request_url) { "http://localhost:#{VCR::SinatraApp.port}/" }
-
-    it 'works correctly with multiple parallel requests' do
-      recorded, played_back = [1, 2].map do
-        responses = []
-
-        VCR.use_cassette("multiple_parallel") do
-          connection.in_parallel do
-            responses << connection.get(request_url)
-            responses << connection.get(request_url)
-          end
-        end
-
-        responses.map(&:body)
-      end
-
-      # there should be no blanks
-      expect(recorded.select { |r| r.to_s == '' }).to eq([])
-      expect(played_back).to eq(recorded)
-    end
-
-    shared_examples_for "exclusive library hook" do
-      def make_request
-        connection.in_parallel { connection.get(request_url) }
-      end
-
-      it 'makes the faraday middleware exclusively enabled for the duration of the request' do
-        expect(VCR.library_hooks).not_to be_disabled(:fakeweb)
-
-        hook_called = false
-        VCR.configuration.after_http_request do
-          hook_called = true
-          expect(VCR.library_hooks).to be_disabled(:fakeweb)
-        end
-
-        make_request
-        expect(VCR.library_hooks).not_to be_disabled(:fakeweb)
-        expect(hook_called).to be true
-      end
-    end
-
-    context 'for an ignored request' do
-      before(:each) { VCR.configuration.ignore_request { true } }
-      it_behaves_like "exclusive library hook"
-    end
-
-    context 'for a stubbed request' do
-      it_behaves_like "exclusive library hook" do
-        before(:each) do
-          stub_requests([http_interaction(request_url)], [:method, :uri])
-        end
-      end
-    end
-
-    context "when another adapter is exclusive" do
-      it 'still makes requests properly' do
-        response = VCR.library_hooks.exclusively_enabled(:typhoeus) do
-          Faraday.get("http://localhost:#{VCR::SinatraApp.port}/")
-        end
-
-        expect(response.body).to eq("GET to root")
-      end
-    end
-
-    context 'for a recorded request' do
-      let!(:inserted_cassette) { VCR.insert_cassette('new_cassette') }
-      before(:each) { expect(VCR).to receive(:record_http_interaction) }
-      it_behaves_like "exclusive library hook"
-    end
-
-    context 'for a disallowed request' do
-      it_behaves_like "exclusive library hook" do
-        undef make_request
-        def make_request
-          expect {
-            connection.in_parallel { connection.get(request_url) }
-          }.to raise_error(VCR::Errors::UnhandledHTTPRequestError)
-        end
-      end
-    end
-
-    it_behaves_like "request hooks", :faraday, :recordable do
-      let!(:inserted_cassette) { VCR.insert_cassette('new_cassette') }
-
-      undef make_request
-      def make_request(disabled = false)
-        response = nil
-        connection.in_parallel do
-          response = connection.get(request_url)
-        end
-        response
-      end
-
-      it 'can be used to eject a cassette after the request is recorded' do
-        VCR.configuration.after_http_request { |request| VCR.eject_cassette }
-
-        expect(VCR).to receive(:record_http_interaction) do |interaction|
-          expect(VCR.current_cassette).to be(inserted_cassette)
-        end
-
-        make_request
-        expect(VCR.current_cassette).to be_nil
-      end
-    end
-  end if defined?(::Typhoeus)
-end

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
-