vcr 3.0.3 → 4.0.0

data/spec/lib/vcr/extensions/net_http_response_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-describe VCR::Net::HTTPResponse do
-  def self.it_allows_the_body_to_be_read(expected_regex)
-    it 'allows the body to be read using #body' do
-      expect(response.body.to_s).to match expected_regex
-    end
-
-    it 'allows the body to be read using #read_body' do
-      expect(response.read_body.to_s).to match expected_regex
-    end
-
-    it 'allows the body to be read using #read_body with a block' do
-      yielded_body = ''
-      response { |r| r.read_body { |s| yielded_body << s.to_s } }
-      expect(yielded_body).to match expected_regex
-    end
-
-    it 'allows the body to be read by passing a destination string to #read_body' do
-      dest = ''
-      ret_val = response { |r| r.read_body(dest) }.body
-      expect(dest.to_s).to match expected_regex
-      expect(ret_val.to_s).to eq(dest)
-    end
-
-    it 'raises an ArgumentError if both a destination string and a block is given to #read_body' do
-      dest = ''
-      expect { response { |r| r.read_body(dest) { |s| } } }.to raise_error(ArgumentError, 'both arg and block given for HTTP method')
-    end
-
-    it 'raises an IOError when #read_body is called twice with a block' do
-      response { |r| r.read_body { |s| } }
-      expect { response { |r| r.read_body { |s| } } }.to raise_error(IOError, /read_body called twice/)
-    end
-
-    it 'raises an IOError when #read_body is called twice with a destination string' do
-      dest = ''
-      response { |r| r.read_body(dest) }
-      expect { response { |r| r.read_body(dest) } }.to raise_error(IOError, /read_body called twice/)
-    end
-  end
-
-  { :get => /GET to root/, :head => /\A\z/ }.each do |http_verb, expected_body_regex|
-    context "for a #{http_verb.to_s.upcase} request" do
-      let(:http_verb_method) { :"request_#{http_verb}" }
-
-      def response(&block)
-        if defined?(@response) && block
-          block.call(@response)
-          return @response
-        end
-
-        @response ||= begin
-          http = Net::HTTP.new('localhost', VCR::SinatraApp.port)
-          res = http.send(http_verb_method, '/', &block)
-          expect(res).not_to be_a(VCR::Net::HTTPResponse)
-          expect(res).not_to be_a(::Net::WebMockHTTPResponse)
-          res
-        end
-      end
-
-      context 'when the body has not already been read' do
-        it_allows_the_body_to_be_read(expected_body_regex)
-      end
-
-      context 'when the body has already been read using #read_body and a dest string' do
-        before(:each) do
-          dest = ''
-          response { |res| res.read_body(dest) }
-          response.extend VCR::Net::HTTPResponse
-        end
-
-        it_allows_the_body_to_be_read(expected_body_regex)
-      end
-
-      context 'when the body has already been read using #body' do
-        before(:each) do
-          response.body
-          response.extend VCR::Net::HTTPResponse
-        end
-
-        it_allows_the_body_to_be_read(expected_body_regex)
-      end
-    end
-  end
-end

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
-