mustwin-vcr 2.9.3

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

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

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

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

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

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

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