mustwin-vcr 2.9.3

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

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+describe "Typhoeus hook", :with_monkey_patches => :typhoeus 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

@@ -0,0 +1,118 @@
+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.delete('patron') if RUBY_VERSION == '1.8.7'
+  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

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

@@ -0,0 +1,182 @@
+require 'spec_helper'
+require 'vcr/library_hooks/faraday'
+
+describe VCR::Middleware::Faraday do
+  http_libs = %w[ typhoeus net_http patron ]
+  http_libs.delete('patron') if RUBY_VERSION == '1.8.7'
+  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