vcr 3.0.3 → 6.2.0

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

@@ -1,104 +0,0 @@
-require 'spec_helper'
-require 'support/shared_example_groups/excon'
-
-describe "Excon hook", :with_monkey_patches => :excon do
-  after(:each) do
-    ::Excon.stubs.clear
-    ::Excon.defaults[:mock] = false
-  end
-
-  def directly_stub_request(method, url, response_body)
-    ::Excon.defaults[:mock] = true
-    ::Excon.stub({ :method => method, :url => url }, { :body => response_body })
-  end
-
-  it_behaves_like 'a hook into an HTTP library', :excon, 'excon', :status_message_not_exposed
-
-  context "when the query is specified as a hash option" do
-    let(:excon) { ::Excon.new("http://localhost:#{VCR::SinatraApp.port}/search") }
-
-    it 'properly records and plays back the response' do
-      allow(VCR).to receive(:real_http_connections_allowed?).and_return(true)
-      recorded, played_back = [1, 2].map do
-        VCR.use_cassette('excon_query', :record => :once) do
-          excon.request(:method => :get, :query => { :q => 'Tolkien' }).body
-        end
-      end
-
-      expect(recorded).to eq(played_back)
-      expect(recorded).to eq('query: Tolkien')
-    end
-  end
-
-  context "when Excon's expects and idempotent middlewares cause errors to be raised" do
-    let(:excon) { ::Excon.new("http://localhost:#{VCR::SinatraApp.port}/404_not_200") }
-
-    def make_request
-      VCR.use_cassette('with_errors', :record => :once) do
-        excon.request(:method => :get, :expects => [200], :idempotent => true).body
-      end
-    end
-
-    it 'records and plays back properly' do
-      expect { make_request }.to raise_error(Excon::Errors::NotFound)
-      expect { make_request }.to raise_error(Excon::Errors::NotFound)
-    end
-  end
-
-  include_examples "Excon streaming"
-
-  context 'when Excon raises an error due to an unexpected response status' do
-    before(:each) do
-      allow(VCR).to receive(:real_http_connections_allowed?).and_return(true)
-    end
-
-    it 'still records properly' do
-      expect(VCR).to receive(:record_http_interaction) do |interaction|
-        expect(interaction.response.status.code).to eq(404)
-        expect(interaction.response.body).to eq('404 not 200')
-      end
-
-      expect {
-        Excon.get("http://localhost:#{VCR::SinatraApp.port}/404_not_200", :expects => 200)
-      }.to raise_error(Excon::Errors::Error)
-    end
-
-    def error_raised_by
-      yield
-    rescue => e
-      return e
-    else
-      raise "No error was raised"
-    end
-
-    it 'raises the same error class as excon itself raises' do
-      real_error, stubbed_error = 2.times.map do
-        error_raised_by do
-          VCR.use_cassette('excon_error', :record => :once) do
-            Excon.get("http://localhost:#{VCR::SinatraApp.port}/not_found", :expects => 200)
-          end
-        end
-      end
-
-      expect(stubbed_error.class).to be(real_error.class)
-    end
-
-    it_behaves_like "request hooks", :excon, :recordable do
-      undef make_request
-      def make_request(disabled = false)
-        expect {
-          Excon.get(request_url, :expects => 404)
-        }.to raise_error(Excon::Errors::Error)
-      end
-    end
-  end
-
-  describe "VCR.configuration.after_library_hooks_loaded hook" do
-    it 'disables the webmock excon adapter so it does not conflict with our typhoeus hook' do
-      expect(::WebMock::HttpLibAdapters::ExconAdapter).to respond_to(:disable!)
-      expect(::WebMock::HttpLibAdapters::ExconAdapter).to receive(:disable!)
-      $excon_after_loaded_hook.conditionally_invoke
-    end
-  end
-end
-

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

@@ -1,169 +0,0 @@
-require 'spec_helper'
-
-describe "FakeWeb hook", :with_monkey_patches => :fakeweb do
-  after(:each) do
-    ::FakeWeb.clean_registry
-  end
-
-  def disable_real_connections
-    ::FakeWeb.allow_net_connect = false
-    ::FakeWeb::NetConnectNotAllowedError
-  end
-
-  def enable_real_connections
-    ::FakeWeb.allow_net_connect = true
-  end
-
-  def directly_stub_request(method, url, response_body)
-    ::FakeWeb.register_uri(method, url, :body => response_body)
-  end
-
-  it_behaves_like 'a hook into an HTTP library', :fakeweb, 'net/http'
-
-  describe "some specific Net::HTTP edge cases" do
-    before(:each) do
-      allow(VCR).to receive(:real_http_connections_allowed?).and_return(true)
-    end
-
-    it 'records the request body when using #post_form' do
-      expect(VCR).to receive(:record_http_interaction) do |interaction|
-        expect(interaction.request.body).to eq("q=ruby")
-      end
-
-      uri = URI("http://localhost:#{VCR::SinatraApp.port}/foo")
-      Net::HTTP.post_form(uri, 'q' => 'ruby')
-    end
-
-    it "does not record headers for which Net::HTTP sets defaults near the end of the real request" do
-      expect(VCR).to receive(:record_http_interaction) do |interaction|
-        expect(interaction.request.headers).not_to have_key('content-type')
-        expect(interaction.request.headers).not_to have_key('host')
-      end
-      Net::HTTP.new('localhost', VCR::SinatraApp.port).send_request('POST', '/', '', { 'x-http-user' => 'me' })
-    end
-
-    it "records headers for which Net::HTTP usually sets defaults when the user manually sets their values" do
-      expect(VCR).to receive(:record_http_interaction) do |interaction|
-        expect(interaction.request.headers['content-type']).to eq(['foo/bar'])
-        expect(interaction.request.headers['host']).to eq(['my-example.com'])
-      end
-      Net::HTTP.new('localhost', VCR::SinatraApp.port).send_request('POST', '/', '', { 'Content-Type' => 'foo/bar', 'Host' => 'my-example.com' })
-    end
-
-    def perform_get_with_returning_block
-      Net::HTTP.new('localhost', VCR::SinatraApp.port).request(Net::HTTP::Get.new('/', {})) do |response|
-        return response
-      end
-    end
-
-    it 'records the interaction when Net::HTTP#request is called with a block with a return statement' do
-      expect(VCR).to receive(:record_http_interaction).once
-      expect(perform_get_with_returning_block.body).to eq("GET to root")
-    end
-
-    def make_post_request
-      Net::HTTP.new('localhost', VCR::SinatraApp.port).post('/record-and-playback', '')
-    end
-
-    it 'records the interaction only once, even when Net::HTTP internally recursively calls #request' do
-      expect(VCR).to receive(:record_http_interaction).once
-      make_post_request
-    end
-
-    it 'properly returns the response body for a post request when recording, stubbing or ignoring the request' do
-      recorded_body = nil
-      VCR.use_cassette("new_cassette", :record => :once) do
-        recorded_body = make_post_request.body
-        expect(recorded_body).to match(/Response \d+/)
-      end
-
-      VCR.use_cassette("new_cassette", :record => :once) do
-        expect(make_post_request.body).to eq(recorded_body)
-      end
-
-      VCR.configuration.ignore_request { |r| true }
-      ignored_body = make_post_request.body
-      expect(ignored_body).not_to eq(recorded_body)
-      expect(ignored_body).to match(/Response \d+/)
-    end
-
-    context 'when the same Net::HTTP request object is used twice' do
-      let(:uri)  { URI("http://localhost:#{VCR::SinatraApp.port}/foo") }
-      let(:http) { Net::HTTP.new(uri.host, uri.port) }
-
-      it 'raises an UnhandledHTTPRequestError when using a cassette that only recorded one request' do
-        VCR.use_cassette("new_cassette", :record => :once) do
-          request = Net::HTTP::Get.new(uri.request_uri)
-          http.request(request)
-        end
-
-        VCR.use_cassette("new_cassette", :record => :once) do
-          request = Net::HTTP::Get.new(uri.request_uri)
-          http.request(request)
-          http.request(request)
-        end
-      end
-    end
-  end
-
-  describe "VCR.configuration.after_library_hooks_loaded hook" do
-    let(:run_hook) { $fakeweb_after_loaded_hook.conditionally_invoke }
-
-    context 'when WebMock has been loaded' do
-      before(:each) do
-        expect(defined?(WebMock)).to be_truthy
-      end
-
-      it 'raises an error since FakeWeb and WebMock cannot both be used simultaneously' do
-        expect { run_hook }.to raise_error(ArgumentError, /cannot use both/)
-      end
-    end
-
-    context 'when WebMock has not been loaded' do
-      let!(:orig_webmock_constant) { ::WebMock }
-      before(:each) { Object.send(:remove_const, :WebMock) }
-      after(:each)  { ::WebMock = orig_webmock_constant }
-
-      it 'does not raise an error' do
-        run_hook # should not raise an error
-      end
-
-      it "warns about FakeWeb deprecation" do
-        expect(::Kernel).to receive(:warn).with("WARNING: VCR's FakeWeb integration is deprecated and will be removed in VCR 4.0.")
-        run_hook
-      end
-    end
-  end
-
-  describe "when a SocketError occurs" do
-    before(:each) do
-      VCR.configuration.ignore_request { |r| true }
-    end
-
-    it_behaves_like "request hooks", :fakeweb, :ignored do
-      undef assert_expected_response
-      def assert_expected_response(response)
-        expect(response).to be_nil
-      end
-
-      undef make_request
-      def make_request(disabled = false)
-        allow_any_instance_of(::Net::HTTP).to receive(:request_without_vcr).and_raise(SocketError)
-        expect {
-          ::Net::HTTP.get_response(URI(request_url))
-        }.to raise_error(SocketError)
-      end
-    end
-  end
-
-  describe "when VCR is turned off" do
-    it 'allows white listed connections' do
-      ::FakeWeb.allow_net_connect = %r[localhost]
-
-      VCR.turn_off!
-
-      uri = URI("http://localhost:#{VCR::SinatraApp.port}/foo")
-      expect(Net::HTTP.get(uri)).to eq("FOO!")
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-require 'spec_helper'
-require 'vcr/library_hooks/faraday'
-
-describe "Faraday hook" do
-  it 'inserts the VCR middleware just before the adapter' do
-    conn = Faraday.new(:url => 'http://sushi.com') do |builder|
-      builder.request  :url_encoded
-      builder.response :logger
-      builder.adapter  :net_http
-    end
-
-    conn.builder.lock!
-    expect(conn.builder.handlers.last(2).map(&:klass)).to eq([
-      VCR::Middleware::Faraday,
-      Faraday::Adapter::NetHttp
-    ])
-  end
-
-  it 'handles the case where no adapter is declared' do
-    conn = Faraday.new
-
-    conn.builder.lock!
-    expect(conn.builder.handlers.last(2).map(&:klass)).to eq([
-      VCR::Middleware::Faraday,
-      Faraday::Adapter::NetHttp
-    ])
-  end
-
-  it 'does nothing if the VCR middleware has already been included' do
-    conn = Faraday.new(:url => 'http://sushi.com') do |builder|
-      builder.use VCR::Middleware::Faraday
-      builder.use Faraday::Response::Logger
-      builder.use Faraday::Adapter::NetHttp
-    end
-
-    conn.builder.lock!
-    expect(conn.builder.handlers.map(&:klass)).to eq([
-      VCR::Middleware::Faraday,
-      Faraday::Response::Logger,
-      Faraday::Adapter::NetHttp
-    ])
-  end
-
-  it 'prints a warning if the faraday connection stack contains a middleware after the HTTP adapter' do
-    conn = Faraday.new(:url => 'http://sushi.com') do |builder|
-      builder.use Faraday::Adapter::NetHttp
-      builder.use Faraday::Response::Logger
-    end
-
-    expect(conn.builder).to receive(:warn).with(/Faraday::Response::Logger/)
-    conn.builder.lock!
-  end
-
-  it 'gracefully handles the case where there is no explicit HTTP adapter' do
-    conn = Faraday.new(:url => 'http://sushi.com') do |builder|
-      builder.request  :url_encoded
-      builder.response :logger
-    end
-
-    conn.builder.lock!
-    expect(conn.builder.handlers.map(&:klass)).to eq([
-      Faraday::Request::UrlEncoded,
-      Faraday::Response::Logger,
-      VCR::Middleware::Faraday
-    ])
-  end
-end
-

data/spec/lib/vcr/library_hooks/typhoeus_0.4_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe "Typhoeus 0.4 hook", :with_monkey_patches => :typhoeus_0_4 do
-  after(:each) do
-    ::Typhoeus::Hydra.clear_stubs
-  end
-
-  def disable_real_connections
-    ::Typhoeus::Hydra.allow_net_connect = false
-    ::Typhoeus::Hydra::NetConnectNotAllowedError
-  end
-
-  def enable_real_connections
-    ::Typhoeus::Hydra.allow_net_connect = true
-  end
-
-  def directly_stub_request(method, url, response_body)
-    response = ::Typhoeus::Response.new(:code => 200, :body => response_body)
-    ::Typhoeus::Hydra.stub(method, url).and_return(response)
-  end
-
-  it_behaves_like 'a hook into an HTTP library', :typhoeus, 'typhoeus 0.4'
-
-  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
-
-    it "warns about Typhoeus 0.4 deprecation" do
-      expect(::Kernel).to receive(:warn).with("WARNING: VCR's Typhoeus 0.4 integration is deprecated and will be removed in VCR 3.0.")
-      $typhoeus_0_4_after_loaded_hook.conditionally_invoke
-    end
-  end
-end if RUBY_INTERPRETER == :mri && ::Typhoeus::VERSION.to_f < 0.5
-

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
-