mustwin-vcr 2.9.3

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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,169 @@
+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 3.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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,36 @@
+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
+