vcr 3.0.3 → 4.0.0

data/spec/lib/vcr_spec.rb

@@ -1,354 +0,0 @@
-require 'spec_helper'
-
-describe VCR do
-  def insert_cassette(name = :cassette_test)
-    VCR.insert_cassette(name)
-  end
-
-  describe '.insert_cassette' do
-    it 'creates a new cassette' do
-      expect(insert_cassette).to be_instance_of(VCR::Cassette)
-    end
-
-    it 'takes over as the #current_cassette' do
-      orig_cassette = VCR.current_cassette
-      new_cassette = insert_cassette
-      expect(new_cassette).not_to eq(orig_cassette)
-      expect(VCR.current_cassette).to eq(new_cassette)
-    end
-
-    it 'raises an error if the stack of inserted cassettes already contains a cassette with the same name' do
-      insert_cassette(:foo)
-      expect {
-        insert_cassette(:foo)
-      }.to raise_error(/There is already a cassette with the same name/)
-    end
-  end
-
-  describe '.eject_cassette' do
-    it 'ejects the current cassette' do
-      cassette = insert_cassette
-      expect(cassette).to receive(:eject)
-      VCR.eject_cassette
-    end
-
-    it 'forwards the given options to `Cassette#eject`' do
-      cassette = insert_cassette
-      expect(cassette).to receive(:eject).with(:some => :options)
-      VCR.eject_cassette(:some => :options)
-    end
-
-    it 'returns the ejected cassette' do
-      cassette = insert_cassette
-      expect(VCR.eject_cassette).to eq(cassette)
-    end
-
-    it 'returns the #current_cassette to the previous one' do
-      cassette1, cassette2 = insert_cassette(:foo1), insert_cassette(:foo2)
-      expect { VCR.eject_cassette }.to change(VCR, :current_cassette).from(cassette2).to(cassette1)
-    end
-
-    it 'keeps the cassette as the current one until after #eject has finished' do
-      cassette = insert_cassette
-      current = nil
-      allow(cassette).to receive(:eject) { current = VCR.current_cassette }
-
-      VCR.eject_cassette
-
-      expect(current).to be(cassette)
-      expect(VCR.current_cassette).not_to be(cassette)
-    end
-
-    it 'properly pops the cassette off the stack even if an error occurs' do
-      cassette = insert_cassette
-      allow(cassette).to receive(:eject) { raise "boom" }
-      expect { VCR.eject_cassette }.to raise_error("boom")
-      expect(VCR.current_cassette).to be_nil
-    end
-  end
-
-  describe '.use_cassette' do
-    it 'inserts a new cassette' do
-      new_cassette = VCR::Cassette.new(:use_cassette_test)
-      expect(VCR).to receive(:insert_cassette).and_return(new_cassette)
-      VCR.use_cassette(:cassette_test) { }
-    end
-
-    it 'yields' do
-      yielded = false
-      VCR.use_cassette(:cassette_test, &lambda { yielded = true })
-      expect(yielded).to be true
-    end
-
-    it 'yields the cassette instance if the block expects an argument' do
-      VCR.use_cassette('name', :record => :new_episodes, &lambda do |cassette|
-        expect(cassette).to equal(VCR.current_cassette)
-      end)
-    end
-
-    it 'yields the cassette instance if the block expects a variable number of args' do
-      VCR.use_cassette('name', :record => :new_episodes) do |*args|
-        expect(args.size).to eq(1)
-        expect(args.first).to equal(VCR.current_cassette)
-      end
-    end
-
-    it 'ejects the cassette' do
-      expect(VCR).to receive(:eject_cassette)
-      VCR.use_cassette(:cassette_test) { }
-    end
-
-    it 'ejects the cassette even if there is an error' do
-      expect(VCR).to receive(:eject_cassette)
-      test_error = Class.new(StandardError)
-      expect { VCR.use_cassette(:cassette_test) { raise test_error } }.to raise_error(test_error)
-    end
-
-    it 'does not eject a cassette if there was an error inserting it' do
-      expect(VCR).to receive(:insert_cassette).and_raise(StandardError.new('Boom!'))
-      expect(VCR).not_to receive(:eject_cassette)
-      expect { VCR.use_cassette(:test) { } }.to raise_error(StandardError, 'Boom!')
-    end
-
-    it 'raises a helpful error if no block is given' do
-      expect {
-        VCR.use_cassette(:test)
-      }.to raise_error(/requires a block/)
-    end
-  end
-
-  describe '.http_interactions' do
-    it 'returns the current_cassette.http_interactions when there is a current cassette' do
-      cassette = VCR.insert_cassette("a cassette")
-      expect(VCR.http_interactions).to be(cassette.http_interactions)
-    end
-
-    it 'returns a null list when there is no current cassette' do
-      expect(VCR.current_cassette).to be_nil
-      expect(VCR.http_interactions).to be(VCR::Cassette::HTTPInteractionList::NullList)
-    end
-  end
-
-  describe '.real_http_connections_allowed?' do
-    context 'when a cassette is inserted' do
-      it 'returns true if the cassette is recording' do
-        VCR.insert_cassette('foo', :record => :all)
-        expect(VCR.current_cassette).to be_recording
-        expect(VCR.real_http_connections_allowed?).to be true
-      end
-
-      it 'returns false if the cassette is not recording' do
-        VCR.insert_cassette('foo', :record => :none)
-        expect(VCR.current_cassette).not_to be_recording
-        expect(VCR.real_http_connections_allowed?).to be false
-      end
-    end
-
-    context 'when no cassette is inserted' do
-      before(:each) do
-        expect(VCR.current_cassette).to be_nil
-      end
-
-      it 'returns true if the allow_http_connections_when_no_cassette option is set to true' do
-        expect(VCR).to be_turned_on
-        VCR.configure { |c| c.allow_http_connections_when_no_cassette = true }
-        expect(VCR.real_http_connections_allowed?).to be true
-      end
-
-      it 'returns true if VCR is turned off' do
-        VCR.turn_off!
-        VCR.configure { |c| c.allow_http_connections_when_no_cassette = false }
-        expect(VCR.real_http_connections_allowed?).to be true
-      end
-
-      it 'returns false if the allow_http_connections_when_no_cassette option is set to false and VCR is turned on' do
-        expect(VCR).to be_turned_on
-        VCR.configure { |c| c.allow_http_connections_when_no_cassette = false }
-        expect(VCR.real_http_connections_allowed?).to be false
-      end
-    end
-  end
-
-  describe '.request_matchers' do
-    it 'always returns the same memoized request matcher registry instance' do
-      expect(VCR.request_matchers).to be_a(VCR::RequestMatcherRegistry)
-      expect(VCR.request_matchers).to be(VCR.request_matchers)
-    end
-  end
-
-  describe '.request_ignorer' do
-    it 'always returns the same memoized request ignorer instance' do
-      expect(VCR.request_ignorer).to be_a(VCR::RequestIgnorer)
-      expect(VCR.request_ignorer).to be(VCR.request_ignorer)
-    end
-  end
-
-  describe '.library_hooks' do
-    it 'always returns the same memoized LibraryHooks instance' do
-      expect(VCR.library_hooks).to be_a(VCR::LibraryHooks)
-      expect(VCR.library_hooks).to be(VCR.library_hooks)
-    end
-  end
-
-  describe '.cassette_serializers' do
-    it 'always returns the same memoized cassette serializers instance' do
-      expect(VCR.cassette_serializers).to be_a(VCR::Cassette::Serializers)
-      expect(VCR.cassette_serializers).to be(VCR.cassette_serializers)
-    end
-  end
-
-  describe ".cassette_persisters" do
-    it "always returns the same memoized Cassette::Persisters instance" do
-      expect(VCR.cassette_persisters).to be_a(VCR::Cassette::Persisters)
-      expect(VCR.cassette_persisters).to be(VCR.cassette_persisters)
-    end
-  end
-
-  describe '.configuration' do
-    it 'returns the configuration object' do
-      expect(VCR.configuration).to be_a(VCR::Configuration)
-    end
-
-    it 'memoizes the instance' do
-      expect(VCR.configuration).to be(VCR.configuration)
-    end
-  end
-
-  describe '.configure' do
-    it 'yields the configuration object' do
-      yielded_object = nil
-      VCR.configure do |obj|
-        yielded_object = obj
-      end
-      expect(yielded_object).to eq(VCR.configuration)
-    end
-  end
-
-  describe '.cucumber_tags' do
-    it 'yields a cucumber tags object' do
-      yielded_object = nil
-      VCR.cucumber_tags do |obj|
-        yielded_object = obj
-      end
-      expect(yielded_object).to be_instance_of(VCR::CucumberTags)
-    end
-  end
-
-  describe '.record_http_interaction' do
-    before(:each) { allow(VCR).to receive(:current_cassette).and_return(current_cassette) }
-    let(:interaction) { double(:request => double) }
-
-    context 'when there is not a current cassette' do
-      let(:current_cassette) { nil }
-
-      it 'does not record a request' do
-        # we can't set a message expectation on nil, but there is no place to record it to...
-        # this mostly tests that there is no error.
-        VCR.record_http_interaction(interaction)
-      end
-    end
-
-    context 'when there is a current cassette' do
-      let(:current_cassette) { double('current cassette') }
-
-      it 'records the request when it should not be ignored' do
-        allow(VCR.request_ignorer).to receive(:ignore?).with(interaction.request).and_return(false)
-        expect(current_cassette).to receive(:record_http_interaction).with(interaction)
-        VCR.record_http_interaction(interaction)
-      end
-
-      it 'does not record the request when it should be ignored' do
-        allow(VCR.request_ignorer).to receive(:ignore?).with(interaction.request).and_return(true)
-        expect(current_cassette).not_to receive(:record_http_interaction)
-        VCR.record_http_interaction(interaction)
-      end
-    end
-  end
-
-  describe '.turn_off!' do
-    it 'indicates it is turned off' do
-      VCR.turn_off!
-      expect(VCR).not_to be_turned_on
-    end
-
-    it 'raises an error if a cassette is in use' do
-      VCR.insert_cassette('foo')
-      expect {
-        VCR.turn_off!
-      }.to raise_error(VCR::CassetteInUseError, /foo/)
-    end
-
-    it 'causes an error to be raised if you insert a cassette while VCR is turned off' do
-      VCR.turn_off!
-      expect {
-        VCR.insert_cassette('foo')
-      }.to raise_error(VCR::TurnedOffError)
-    end
-
-    it 'raises an ArgumentError when given an invalid option' do
-      expect {
-        VCR.turn_off!(:invalid_option => true)
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'sets ignore_cassettes to false' do
-      VCR.turn_off!
-      expect(VCR.send(:ignore_cassettes?)).to equal(false)
-    end
-
-    context 'when `:ignore_cassettes => true` is passed' do
-      before(:each) { VCR.turn_off!(:ignore_cassettes => true) }
-
-      it 'ignores cassette insertions' do
-        VCR.insert_cassette('foo')
-        expect(VCR.current_cassette).to be_nil
-      end
-
-      it 'still runs a block passed to use_cassette' do
-        yielded = false
-
-        VCR.use_cassette('foo') do
-          yielded = true
-          expect(VCR.current_cassette).to be_nil
-        end
-
-        expect(yielded).to be true
-      end
-    end
-  end
-
-  describe '.turn_on!' do
-    before(:each) { VCR.turn_off! }
-
-    it 'indicates it is turned on' do
-      VCR.turn_on!
-      expect(VCR).to be_turned_on
-    end
-  end
-
-  describe '.turned_off' do
-    it 'yields with VCR turned off' do
-      expect(VCR).to be_turned_on
-      yielded = false
-
-      VCR.turned_off do
-        yielded = true
-        expect(VCR).not_to be_turned_on
-      end
-
-      expect(yielded).to eq(true)
-      expect(VCR).to be_turned_on
-    end
-
-    it 'passes options through to .turn_off!' do
-      expect(VCR).to receive(:turn_off!).with(:ignore_cassettes => true)
-      VCR.turned_off(:ignore_cassettes => true) { }
-    end
-  end
-
-  describe '.turned_on?' do
-    it 'is on by default' do
-      expect(VCR).to be_turned_on
-    end
-  end
-end

data/spec/monkey_patches.rb

@@ -1,186 +0,0 @@
-module MonkeyPatches
-  extend self
-
-  NET_HTTP_SINGLETON = class << Net::HTTP; self; end
-
-  NET_HTTP_MONKEY_PATCHES = [
-    [Net::BufferedIO,    :initialize],
-    [Net::HTTP,          :request],
-    [Net::HTTP,          :connect],
-    [NET_HTTP_SINGLETON, :socket_type]
-  ]
-
-  ALL_MONKEY_PATCHES = NET_HTTP_MONKEY_PATCHES.dup
-
-  def enable!(scope)
-    case scope
-      when :fakeweb
-        realias_net_http :with_fakeweb
-        enable!(:vcr) # fakeweb hook relies upon VCR's Net::HTTP monkey patch
-      when :webmock
-        ::WebMock.reset!
-        ::WebMock::HttpLibAdapters::NetHttpAdapter.enable!
-        ::WebMock::HttpLibAdapters::TyphoeusAdapter.enable! if defined?(::Typhoeus)
-        ::WebMock::HttpLibAdapters::ExconAdapter.enable! if defined?(::Excon)
-        $original_webmock_callbacks.each do |cb|
-          ::WebMock::CallbackRegistry.add_callback(cb[:options], cb[:block])
-        end
-      when :typhoeus
-        $original_typhoeus_global_hooks.each do |hook|
-          ::Typhoeus.on_complete << hook
-        end
-        ::Typhoeus.before.clear
-        $original_typhoeus_before_hooks.each do |hook|
-          ::Typhoeus.before << hook
-        end
-      when :typhoeus_0_4
-        ::Typhoeus::Hydra.global_hooks = $original_typhoeus_global_hooks
-        ::Typhoeus::Hydra.stub_finders.clear
-        $original_typhoeus_stub_finders.each do |finder|
-          ::Typhoeus::Hydra.stub_finders << finder
-        end
-      when :excon
-        VCR::LibraryHooks::Excon.configure_middleware
-      when :vcr
-        realias Net::HTTP, :request, :with_vcr
-      else raise ArgumentError.new("Unexpected scope: #{scope}")
-    end
-  end
-
-  def disable_all!
-    realias_all :without_monkeypatches
-
-    if defined?(::WebMock::HttpLibAdapters)
-      ::WebMock::HttpLibAdapters::NetHttpAdapter.disable!
-      ::WebMock::HttpLibAdapters::TyphoeusAdapter.disable! if defined?(::Typhoeus)
-      ::WebMock::HttpLibAdapters::ExconAdapter.disable! if defined?(::Excon)
-      ::WebMock::CallbackRegistry.reset
-      ::WebMock::StubRegistry.instance.request_stubs = []
-    end
-
-    if defined?(::Typhoeus.before)
-      ::Typhoeus.on_complete.clear
-      ::Typhoeus.before.clear
-    elsif defined?(::Typhoeus::Hydra)
-      ::Typhoeus::Hydra.clear_global_hooks
-      ::Typhoeus::Hydra.stub_finders.clear
-    end
-
-    if defined?(::Excon)
-      ::Excon.defaults[:middlewares].delete(VCR::Middleware::Excon::Request)
-      ::Excon.defaults[:middlewares].delete(VCR::Middleware::Excon::Response)
-    end
-  end
-
-  def init
-    # capture the monkey patched definitions so we can realias to them in the future
-    ALL_MONKEY_PATCHES.each do |mp|
-      capture_method_definition(mp.first, mp.last, false)
-    end
-  end
-
-  private
-
-  def capture_method_definition(klass, method, original)
-    klass.class_eval do
-      monkeypatch_methods = [:vcr, :fakeweb].select { |m| method_defined?(:"#{method}_with_#{m}") }
-
-      if original
-        if monkeypatch_methods.size > 0
-          raise "The following monkeypatch methods have already been defined #{method}: #{monkey_patch_methods.inspect}"
-        end
-        alias_name = :"#{method}_without_monkeypatches"
-      else
-        if monkeypatch_methods.size == 0
-          raise "No monkey patch methods have been defined for #{method}"
-        end
-        alias_name = :"#{method}_with_monkeypatches"
-      end
-
-      alias_method alias_name, method
-    end
-  end
-
-  # capture the original method definitions before the monkey patches have been defined
-  # so we can realias to the originals in the future
-  ALL_MONKEY_PATCHES.each do |mp|
-    capture_method_definition(mp.first, mp.last, true)
-  end
-
-  def realias(klass, method, alias_extension)
-    klass.class_eval do
-      old_verbose, $VERBOSE = $VERBOSE, nil
-      alias_method method, :"#{method}_#{alias_extension}"
-      $VERBOSE = old_verbose
-    end
-  end
-
-  def realias_all(alias_extension)
-    ALL_MONKEY_PATCHES.each do |mp|
-      realias mp.first, mp.last, alias_extension
-    end
-  end
-
-  def realias_net_http(alias_extension)
-    NET_HTTP_MONKEY_PATCHES.each do |mp|
-      realias mp.first, mp.last, alias_extension
-    end
-  end
-end
-
-# Require all the HTTP libraries--these must be required before WebMock
-# for WebMock to work with them.
-require 'httpclient'
-
-if RUBY_INTERPRETER == :mri
-  require 'typhoeus'
-  begin
-    require 'patron'
-    require 'em-http-request'
-    require 'curb'
-  rescue LoadError
-    # these are not always available, depending on the Gemfile used
-    warn $!.message
-  end
-end
-
-if defined?(::Typhoeus.before)
-  require 'vcr/library_hooks/typhoeus'
-  $typhoeus_after_loaded_hook = VCR.configuration.hooks[:after_library_hooks_loaded].last
-  $original_typhoeus_global_hooks = Typhoeus.on_complete.dup
-  $original_typhoeus_before_hooks = Typhoeus.before.dup
-elsif defined?(::Typhoeus::Hydra.global_hooks)
-  require 'vcr/library_hooks/typhoeus'
-  $typhoeus_0_4_after_loaded_hook = VCR.configuration.hooks[:after_library_hooks_loaded].first
-  $typhoeus_after_loaded_hook = VCR.configuration.hooks[:after_library_hooks_loaded].last
-  $original_typhoeus_global_hooks = Typhoeus::Hydra.global_hooks.dup
-  $original_typhoeus_stub_finders = Typhoeus::Hydra.stub_finders.dup
-end
-
-require 'vcr/library_hooks/fakeweb'
-$fakeweb_after_loaded_hook = VCR.configuration.hooks[:after_library_hooks_loaded].last
-
-# All Net::HTTP monkey patches have now been loaded, so capture the
-# appropriate method definitions so we can disable them later.
-MonkeyPatches.init
-
-# Disable FakeWeb/VCR Net::HTTP patches before WebMock
-# subclasses Net::HTTP and inherits them...
-MonkeyPatches.disable_all!
-
-require 'vcr/library_hooks/webmock'
-$original_webmock_callbacks = ::WebMock::CallbackRegistry.callbacks
-
-require 'vcr/library_hooks/excon'
-$excon_after_loaded_hook = VCR.configuration.hooks[:after_library_hooks_loaded].last
-
-# disable all by default; we'll enable specific ones when we need them
-MonkeyPatches.disable_all!
-
-RSpec.configure do |config|
-  [:fakeweb, :webmock, :vcr, :typhoeus, :typhoeus_0_4, :excon].each do |scope|
-    config.before(:all, :with_monkey_patches => scope) { MonkeyPatches.enable!(scope) }
-    config.after(:all,  :with_monkey_patches => scope) { MonkeyPatches.disable_all!   }
-  end
-end
-