vcr 3.0.3 → 4.0.0

data/spec/lib/vcr/library_hooks/typhoeus_spec.rb

@@ -1,162 +0,0 @@
-require 'spec_helper'
-
-describe "Typhoeus hook", :with_monkey_patches => :typhoeus, :if => (RUBY_INTERPRETER == :mri) do
-  after(:each) do
-    ::Typhoeus::Expectation.clear
-  end
-
-  def disable_real_connections
-    ::Typhoeus::Config.block_connection = true
-    ::Typhoeus::Errors::NoStub
-  end
-
-  def enable_real_connections
-    ::Typhoeus::Config.block_connection = false
-  end
-
-  def directly_stub_request(method, url, response_body)
-    response = ::Typhoeus::Response.new(:code => 200, :body => response_body)
-    ::Typhoeus.stub(url, :method => method).and_return(response)
-  end
-
-  it_behaves_like 'a hook into an HTTP library', :typhoeus, 'typhoeus'
-
-  describe "VCR.configuration.after_library_hooks_loaded hook" do
-    it 'disables the webmock typhoeus adapter so it does not conflict with our typhoeus hook' do
-      expect(::WebMock::HttpLibAdapters::TyphoeusAdapter).to receive(:disable!)
-      $typhoeus_after_loaded_hook.conditionally_invoke
-    end
-  end
-
-  context 'when there are nested hydra queues' do
-    def make_requests
-      VCR.use_cassette("nested") do
-        response_1 = response_2 = nil
-
-        hydra   = Typhoeus::Hydra.new
-        request = Typhoeus::Request.new("http://localhost:#{VCR::SinatraApp.port}/")
-
-        request.on_success do |r1|
-          response_1 = r1
-
-          nested = Typhoeus::Request.new("http://localhost:#{VCR::SinatraApp.port}/foo")
-          nested.on_success { |r2| response_2 = r2 }
-
-          hydra.queue(nested)
-        end
-
-        hydra.queue(request)
-        hydra.run
-
-        return body_for(response_1), body_for(response_2)
-      end
-    end
-
-    def body_for(response)
-      return :no_response if response.nil?
-      response.body
-    end
-
-    it 'records and plays back properly' do
-      recorded = make_requests
-      played_back = make_requests
-
-      expect(played_back).to eq(recorded)
-    end
-  end
-
-  context "when used with a typhoeus-based faraday connection" do
-    let(:base_url) { "http://localhost:#{VCR::SinatraApp.port}" }
-
-    let(:conn) do
-      Faraday.new(:url => base_url) do |faraday|
-        faraday.adapter  :typhoeus
-      end
-    end
-
-    def get_response
-      # Ensure faraday hook doesn't handle the request.
-      VCR.library_hooks.exclusively_enabled(:typhoeus) do
-        VCR.use_cassette("faraday") do
-          conn.get("/")
-        end
-      end
-    end
-
-    it 'records and replays headers correctly' do
-      recorded = get_response
-      played_back = get_response
-
-      expect(played_back.headers).to eq(recorded.headers)
-    end
-  end
-
-  context 'when a request is made with a hash for the POST body' do
-    def make_request
-      VCR.use_cassette("hash_body") do
-        Typhoeus::Request.post(
-          "http://localhost:#{VCR::SinatraApp.port}/return-request-body",
-          :body => { :foo => "17" }
-        )
-      end
-    end
-
-    it 'records and replays correctly' do
-      recorded = make_request
-      played_back = make_request
-
-      expect(recorded.body).to eq("foo=17")
-      expect(played_back.body).to eq(recorded.body)
-    end
-  end
-
-  context '#effective_url' do
-    ResponseValues = Struct.new(:status, :body, :effective_url)
-
-    def url_for(path)
-      "http://localhost:#{VCR::SinatraApp.port}#{path}"
-    end
-
-    def make_single_request(path, options = {})
-      VCR.use_cassette('single') do |cassette|
-        response = Typhoeus::Request.new(url_for(path), options).run
-
-        yield cassette if block_given?
-
-        ResponseValues.new(
-          response.code,
-          response.body,
-          response.effective_url
-        )
-      end
-    end
-
-    it 'records and plays back properly' do
-      recorded = make_single_request('/')
-      played_back = make_single_request('/')
-
-      expect(recorded.effective_url).to eq(url_for('/'))
-      expect(played_back).to eq(recorded)
-    end
-
-    it 'falls back to the request url when it was not recorded (e.g. on VCR <= 2.5.0)' do
-      make_single_request('/') do |cassette|
-        cassette.new_recorded_interactions.each { |i| i.response.adapter_metadata.clear }
-      end
-
-      played_back = make_single_request('/')
-      expect(played_back.effective_url).to eq(url_for('/'))
-    end
-
-    context "when following redirects" do
-      it 'records and plays back properly' do
-        recorded = make_single_request('/redirect-to-root', :followlocation => true)
-        played_back = make_single_request('/redirect-to-root', :followlocation => true)
-
-        expect(recorded.effective_url).to eq(url_for('/'))
-        expect(played_back).to eq(recorded)
-      end
-    end
-  end
-end
-

data/spec/lib/vcr/library_hooks/webmock_spec.rb

@@ -1,117 +0,0 @@
-require 'spec_helper'
-require 'support/shared_example_groups/excon'
-
-describe "WebMock hook", :with_monkey_patches => :webmock do
-  after(:each) do
-    ::WebMock.reset!
-  end
-
-  def disable_real_connections(options = {})
-    ::WebMock.disable_net_connect!(options)
-    ::WebMock::NetConnectNotAllowedError
-  end
-
-  def enable_real_connections
-    ::WebMock.allow_net_connect!
-  end
-
-  def directly_stub_request(method, url, response_body)
-    ::WebMock.stub_request(method, url).to_return(:body => response_body)
-  end
-
-  describe "our WebMock.after_request hook" do
-    let(:webmock_request) { ::WebMock::RequestSignature.new(:get, "http://foo.com/", :body => "", :headers => {}) }
-    let(:webmock_response) { ::WebMock::Response.new(:body => 'OK', :status => [200, '']) }
-
-    def run_after_request_callback
-      ::WebMock::CallbackRegistry.invoke_callbacks(
-        { :real_request => true },
-        webmock_request,
-        webmock_response)
-    end
-
-    it 'removes the @__typed_vcr_request instance variable so as not to pollute the webmock object' do
-      request = VCR::Request::Typed.new(VCR::Request, :ignored?)
-      webmock_request.instance_variable_set(:@__typed_vcr_request, request)
-
-      run_after_request_callback
-      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
-      let(:warner) { VCR::LibraryHooks::WebMock }
-      before { allow(warner).to receive(:warn) }
-
-      it 'records the HTTP interaction properly' do
-        expect(VCR).to receive(:record_http_interaction) do |i|
-          expect(i.request.uri).to eq("http://foo.com/")
-          expect(i.response.body).to eq("OK")
-        end
-
-        run_after_request_callback
-      end
-
-      it 'invokes the after_http_request hook with an :unknown request' do
-        request = nil
-        VCR.configuration.after_http_request do |req, res|
-          request = req
-        end
-
-        run_after_request_callback
-        expect(request.uri).to eq("http://foo.com/")
-        expect(request.type).to eq(:unknown)
-      end
-
-      it 'prints a warning' do
-        expect(warner).to receive(:warn).at_least(:once).with(/bug.*after_request/)
-
-        run_after_request_callback
-      end
-    end
-  end
-
-  http_libs = %w[net/http patron httpclient em-http-request curb typhoeus excon]
-  http_libs.each do |lib|
-    other = []
-    other << :status_message_not_exposed if lib == 'excon'
-    it_behaves_like 'a hook into an HTTP library', :webmock, lib, *other do
-      if lib == 'net/http'
-        def normalize_request_headers(headers)
-          headers.merge(DEFAULT_REQUEST_HEADERS)
-        end
-      end
-    end
-
-    http_lib_unsupported = (RUBY_INTERPRETER != :mri && lib =~ /(typhoeus|curb|patron|em-http)/)
-
-    adapter_module = HTTP_LIBRARY_ADAPTERS.fetch(lib)
-    describe "using #{adapter_module.http_library_name}", :unless => http_lib_unsupported do
-      include adapter_module
-
-      let!(:request_url) { "http://localhost:#{VCR::SinatraApp.port}/foo" }
-
-      context 'when real connections are disabled and VCR is turned off' do
-        it 'can allow connections to localhost' do
-          VCR.turn_off!
-          disable_real_connections(:allow_localhost => true)
-
-          expect {
-            make_http_request(:get, request_url)
-          }.to_not raise_error
-        end
-
-        it 'can allow connections to matching urls' do
-          VCR.turn_off!
-          disable_real_connections(:allow => /foo/)
-
-          expect {
-            make_http_request(:get, request_url)
-          }.to_not raise_error
-        end
-      end
-    end
-  end
-
-  it_behaves_like "Excon streaming"
-end
-

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