vcr 3.0.3 → 4.0.0

data/spec/lib/vcr/test_frameworks/cucumber_spec.rb

@@ -1,107 +0,0 @@
-require 'spec_helper'
-
-describe VCR::CucumberTags do
-  subject { described_class.new(self) }
-  let(:before_blocks_for_tags) { {} }
-  let(:after_blocks_for_tags) { {} }
-
-  def scenario(name)
-    double(:name => name, :feature => double(:name => "My feature name\nThe preamble text is not included"), :failed? => false)
-  end
-
-  let(:current_scenario) { scenario "My scenario name\nThe preamble text is not included" }
-
-  # define our own Before/After so we can test this in isolation from cucumber's implementation.
-  def Before(tag, &block)
-    before_blocks_for_tags[tag.sub('@', '')] = block
-  end
-
-  def After(tag, &block)
-    after_blocks_for_tags[tag.sub('@', '')] = block
-  end
-
-  def test_tag(cassette_attribute, tag, expected_value, scenario=current_scenario)
-    expect(VCR.current_cassette).to be_nil
-
-    before_blocks_for_tags[tag].call(scenario)
-    expect(VCR.current_cassette.send(cassette_attribute)).to eq(expected_value)
-    after_blocks_for_tags[tag].call(scenario)
-
-    expect(VCR.current_cassette).to be_nil
-  end
-
-  %w(tags tag).each do |tag_method|
-    describe "##{tag_method}" do
-      it "creates a cucumber Around hook for each given tag so that the scenario runs with the cassette inserted" do
-        subject.send(tag_method, 'tag1', 'tag2')
-
-        test_tag(:name, 'tag1', 'cucumber_tags/tag1')
-        test_tag(:name, 'tag2', 'cucumber_tags/tag2')
-      end
-
-      it "works with tags that start with an @" do
-        subject.send(tag_method, '@tag1', '@tag2')
-
-        test_tag(:name, 'tag1', 'cucumber_tags/tag1')
-        test_tag(:name, 'tag2', 'cucumber_tags/tag2')
-      end
-
-      it "passes along the given options to the cassette" do
-        subject.send(tag_method, 'tag1', :record => :none)
-        subject.send(tag_method, 'tag2', :record => :new_episodes)
-
-        test_tag(:record_mode, 'tag1', :none)
-        test_tag(:record_mode, 'tag2', :new_episodes)
-      end
-
-      context 'with :use_scenario_name as an option' do
-        it "uses the scenario's name as the cassette name" do
-          subject.send(tag_method, 'tag1', :use_scenario_name => true)
-
-          test_tag(:name, 'tag1', 'My feature name/My scenario name')
-        end
-
-        it "makes a unique name for each element of scenario outline" do
-          subject.send(tag_method, 'tag1', :use_scenario_name => true)
-
-          scenario_with_outline = double(:name => "My row name", :failed? => false,
-                                       :scenario_outline => double(:feature => double(:name => "My feature name\nThe preamble text is not included"),
-                                                                 :name => "My scenario outline name"))
-          test_tag(:name, 'tag1', 'My feature name/My scenario outline name/My row name', scenario_with_outline)
-        end
-
-        it 'does not pass :use_scenario_name along the given options to the cassette' do
-          subject.send(tag_method, 'tag1', :use_scenario_name => true)
-
-          expect(VCR::Cassette).to receive(:new).with(anything, hash_not_including(:use_scenario_name))
-          before_blocks_for_tags['tag1'].call(current_scenario)
-        end
-
-        it 'does not modify the options passed to the cassette' do
-          original_options = { :use_scenario_name => true, :record => :none }
-          subject.send(tag_method, 'tag1', original_options)
-          before_blocks_for_tags['tag1'].call(current_scenario)
-
-          expect(original_options.size).to eq(2)
-          expect(original_options[:use_scenario_name]).to eq(true)
-          expect(original_options[:record]).to eq(:none)
-        end
-
-        it "works properly when multiple scenarios use the tag" do
-          subject.send(tag_method, 'tag1', :use_scenario_name => true)
-
-          test_tag(:name, 'tag1', 'My feature name/Foo', scenario("Foo"))
-          test_tag(:name, 'tag1', 'My feature name/Bar', scenario("Bar"))
-        end
-      end
-    end
-  end
-
-  describe '.tags' do
-    it 'returns the list of cucumber tags' do
-      subject.tags 'tag1', 'tag2'
-      subject.tags 'tag3', 'tag4'
-      expect(described_class.tags[-4, 4]).to eq(%w(@tag1 @tag2 @tag3 @tag4))
-    end
-  end
-end

data/spec/lib/vcr/test_frameworks/rspec_spec.rb

@@ -1,94 +0,0 @@
-require 'spec_helper'
-
-VCR.configuration.configure_rspec_metadata!
-
-describe VCR::RSpec::Metadata, :skip_vcr_reset do
-  before(:all) { VCR.reset! }
-  after(:each) { VCR.reset! }
-
-  context 'an example group', :vcr do
-    context 'with a nested example group' do
-      it 'uses a cassette for any examples' do
-        expect(VCR.current_cassette.name.split('/')).to eq([
-          'VCR::RSpec::Metadata',
-          'an example group',
-          'with a nested example group',
-          'uses a cassette for any examples'
-        ])
-      end
-    end
-
-    context 'when the spec has no description' do
-      it do
-        expect(VCR.current_cassette.name.split('/')).to eq([
-          'VCR::RSpec::Metadata',
-          'an example group',
-          'when the spec has no description',
-          '1:1:2:1'
-        ])
-      end
-    end
-  end
-
-  context 'with the cassette name overridden at the example group level', :vcr => { :cassette_name => 'foo' } do
-    it 'overrides the cassette name for an example' do
-      expect(VCR.current_cassette.name).to eq('foo')
-    end
-
-    it 'overrides the cassette name for another example' do
-      expect(VCR.current_cassette.name).to eq('foo')
-    end
-  end
-
-  it 'allows the cassette name to be overriden', :vcr => { :cassette_name => 'foo' } do
-    expect(VCR.current_cassette.name).to eq('foo')
-  end
-
-  it 'allows the cassette options to be set', :vcr => { :match_requests_on => [:method] } do
-    expect(VCR.current_cassette.match_requests_on).to eq([:method])
-  end
-end
-
-describe VCR::RSpec::Macros do
-  extend described_class
-
-  describe '#use_vcr_cassette' do
-    def self.perform_test(context_name, expected_cassette_name, *args, &block)
-      context context_name do
-        after(:each) do |example|
-          if example.metadata[:test_ejection]
-            expect(VCR.current_cassette).to be_nil
-          end
-        end
-
-        use_vcr_cassette(*args)
-
-        it 'ejects the cassette in an after hook', :test_ejection do
-          expect(VCR.current_cassette).to be_a(VCR::Cassette)
-        end
-
-        it "creates a cassette named '#{expected_cassette_name}" do
-          expect(VCR.current_cassette.name).to eq(expected_cassette_name)
-        end
-
-        module_eval(&block) if block
-      end
-    end
-
-    perform_test 'when called with an explicit name', 'explicit_name', 'explicit_name'
-
-    perform_test 'when called with an explicit name and some options', 'explicit_name', 'explicit_name', :match_requests_on => [:method, :host] do
-      it 'uses the provided cassette options' do
-        expect(VCR.current_cassette.match_requests_on).to eq([:method, :host])
-      end
-    end
-
-    perform_test 'when called with nothing', 'VCR::RSpec::Macros/#use_vcr_cassette/when called with nothing'
-
-    perform_test 'when called with some options', 'VCR::RSpec::Macros/#use_vcr_cassette/when called with some options', :match_requests_on => [:method, :host] do
-      it 'uses the provided cassette options' do
-        expect(VCR.current_cassette.match_requests_on).to eq([:method, :host])
-      end
-    end
-  end
-end

data/spec/lib/vcr/util/hooks_spec.rb

@@ -1,158 +0,0 @@
-require 'spec_helper'
-
-describe VCR::Hooks::FilteredHook do
-  describe "#conditionally_invoke" do
-    it 'invokes the hook' do
-      called = false
-      subject.hook = lambda { called = true }
-      subject.conditionally_invoke
-      expect(called).to be true
-    end
-
-    it 'forwards the given arguments to the hook' do
-      args = nil
-      subject.hook = lambda { |a, b| args = [a, b] }
-      subject.conditionally_invoke(3, 5)
-      expect(args).to eq([3, 5])
-    end
-
-    it 'forwards only as many arguments as the hook block accepts' do
-      args = nil
-      subject.hook = lambda { |a| args = [a] }
-      subject.conditionally_invoke(3, 5)
-      expect(args).to eq([3])
-    end
-
-    it 'does not invoke the hook if all of the filters return false' do
-      called = false
-      subject.hook = lambda { called = true }
-      subject.filters = lambda { false }
-      subject.conditionally_invoke
-      expect(called).to be false
-    end
-
-    it 'does not invoke the hook if any of the filters returns false' do
-      called = false
-      subject.hook = lambda { called = true }
-      subject.filters = [lambda { false }, lambda { true }]
-      subject.conditionally_invoke
-      expect(called).to be false
-    end
-
-    it 'forwards arguments to the filters' do
-      filter_args = nil
-      subject.filters = lambda { |a, b| filter_args = [a, b]; false }
-      subject.conditionally_invoke(3, 5)
-      expect(filter_args).to eq([3, 5])
-    end
-
-    it 'handles splat args properly' do
-      filter_args = nil
-      subject.filters = lambda { |*args| filter_args = args; false }
-      subject.conditionally_invoke(3, 5)
-      expect(filter_args).to eq([3, 5])
-    end
-
-    it 'forwards only as many arguments as the filter blocks accept' do
-      args1 = args2 = nil
-      subject.filters = [
-        lambda { |a| args1 = [a]; true },
-        lambda { |a, b| args2 = [a, b]; false }
-      ]
-
-      subject.conditionally_invoke(3, 5)
-      expect(args1).to eq([3])
-      expect(args2).to eq([3, 5])
-    end
-
-    it '#to_procs the filter objects' do
-      filter_called = false
-      subject.hook = lambda { }
-      subject.filters = [double(:to_proc => lambda { filter_called = true })]
-      subject.conditionally_invoke
-      expect(filter_called).to be true
-    end
-  end
-end
-
-describe VCR::Hooks do
-  let(:hooks_class) { Class.new { include VCR::Hooks } }
-
-  subject { hooks_class.new }
-  let(:invocations) { [] }
-
-  before(:each) do
-    hooks_class.instance_eval do
-      define_hook :before_foo
-      define_hook :before_bar, :prepend
-    end
-  end
-
-  it 'allows the class to override the hook method and super to the main definition' do
-    override_called = nil
-
-    hooks_class.class_eval do
-      define_method :before_foo do |&block|
-        override_called = true
-        super(&block)
-      end
-    end
-
-    subject.before_foo { }
-    expect(override_called).to be true
-  end
-
-  describe '#clear_hooks' do
-    it 'clears all hooks' do
-      subject.before_foo { invocations << :callback }
-      subject.clear_hooks
-      subject.invoke_hook(:before_foo)
-      expect(invocations).to be_empty
-    end
-  end
-
-  describe '#invoke_hook' do
-    it 'invokes each of the callbacks' do
-      subject.before_foo { invocations << :callback_1 }
-      subject.before_foo { invocations << :callback_2 }
-
-      expect(invocations).to be_empty
-      subject.invoke_hook(:before_foo)
-      expect(invocations).to eq([:callback_1, :callback_2])
-    end
-
-    it 'maps the return value of each callback' do
-      subject.before_foo { 17 }
-      subject.before_foo { 12 }
-      expect(subject.invoke_hook(:before_foo)).to eq([17, 12])
-    end
-
-    it 'does not invoke any filtered callbacks' do
-      subject.before_foo(:real?) { invocations << :blue_callback }
-      subject.invoke_hook(:before_foo, double(:real? => false))
-      expect(invocations).to be_empty
-    end
-
-    it 'invokes them in reverse order if the hook was defined with :prepend' do
-      subject.before_bar { 17 }
-      subject.before_bar { 12 }
-      expect(subject.invoke_hook(:before_bar)).to eq([12, 17])
-    end
-  end
-
-  describe "#has_hooks_for?" do
-    it 'returns false when given an unrecognized hook name' do
-      expect(subject).not_to have_hooks_for(:abcd)
-    end
-
-    it 'returns false when given the name of a defined hook that has no registered callbacks' do
-      expect(subject).not_to have_hooks_for(:before_foo)
-    end
-
-    it 'returns true when given the name of a defined hook that has registered callbacks' do
-      subject.before_foo { }
-      expect(subject).to have_hooks_for(:before_foo)
-    end
-  end
-end
-

data/spec/lib/vcr/util/internet_connection_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe VCR::InternetConnection do
-  describe '.available?' do
-    before(:each) do
-      described_class.send(:remove_instance_variable, :@available) if described_class.instance_variable_defined?(:@available)
-    end
-
-    def stub_pingecho_with(value)
-      allow(VCR::Ping).to receive(:pingecho).with("example.com", anything, anything).and_return(value)
-    end
-
-    context 'when pinging example.com succeeds' do
-      it 'returns true' do
-        stub_pingecho_with(true)
-        expect(described_class).to be_available
-      end
-
-      it 'memoizes the value so no extra pings are made' do
-        expect(VCR::Ping).to receive(:pingecho).once.and_return(true)
-        3.times { described_class.available? }
-      end
-    end
-
-    context 'when pinging example.com fails' do
-      it 'returns false' do
-        stub_pingecho_with(false)
-        expect(described_class).not_to be_available
-      end
-
-      it 'memoizes the value so no extra pings are made' do
-        expect(VCR::Ping).to receive(:pingecho).once.and_return(false)
-        3.times { described_class.available? }
-      end
-    end
-  end
-end

data/spec/lib/vcr/util/version_checker_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-module VCR
-  describe VersionChecker do
-    it 'raises an error if the major version is too low' do
-      checker = VersionChecker.new('foo', '0.7.3', '1.0.0')
-      expect { checker.check_version! }.to raise_error(Errors::LibraryVersionTooLowError)
-    end
-
-    it 'raises an error if the minor version is too low' do
-      checker = VersionChecker.new('foo', '1.0.99', '1.1.3')
-      expect { checker.check_version! }.to raise_error(Errors::LibraryVersionTooLowError)
-    end
-
-    it 'raises an error if the patch version is too low' do
-      checker = VersionChecker.new('foo', '1.0.8', '1.0.10')
-      expect { checker.check_version! }.to raise_error(Errors::LibraryVersionTooLowError)
-    end
-
-    it 'does not raise an error when the version is equal' do
-      checker = VersionChecker.new('foo', '1.0.0', '1.0.0')
-      expect { checker.check_version! }.not_to raise_error
-    end
-
-    it 'does not raise an error when the version is higher' do
-      checker = VersionChecker.new('foo', '2.0.0', '1.0.0')
-      expect { checker.check_version! }.not_to raise_error
-    end
-  end
-end
-

data/spec/lib/vcr/version_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe "VCR.version" do
-  subject { VCR.version }
-
-  it { should =~ /\A\d+\.\d+\.\d+(\.\w+)?\z/ }
-
-  describe '#parts' do
-    subject { super().parts }
-    it { should be_instance_of(Array)  }
-  end
-
-  describe '#major' do
-    subject { super().major }
-    it { should be_instance_of(Fixnum) }
-  end
-
-  describe '#minor' do
-    subject { super().minor }
-    it { should be_instance_of(Fixnum) }
-  end
-
-  describe '#patch' do
-    subject { super().patch }
-    it { should be_instance_of(Fixnum) }
-  end
-end