site_prism.vcr 0.0.1

data/spec/unit/dsl/adjuster_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe SPV::DSL::Adjuster do
+  let(:raw_fixtures)     { 'some fixtures' }
+  let(:fixtures)         { double }
+  let(:tmp_keeper)       { double(fixtures: raw_fixtures, clean_fixtures: true) }
+  let(:options)          { double(waiter: :wait_for_me) }
+
+  before do
+    SPV::Fixtures::TmpKeeper.stub(:new).and_return(tmp_keeper)
+  end
+
+  subject { described_class.new(options, fixtures) }
+
+  describe '#replace' do
+    let(:replaced_fixtures) { 'replaced fixtures' }
+
+    before do
+      fixtures.stub(:replace).and_return(replaced_fixtures)
+    end
+
+    it 'replaces fixtures' do
+      expect(fixtures).to receive(:replace).with(raw_fixtures)
+
+      subject.replace
+    end
+
+    it 'cleans fixtures being kept in the fixtures handler' do
+      expect(tmp_keeper).to receive(:clean_fixtures)
+
+      subject.replace
+    end
+
+    it 'returns a new container with fixtures' do
+      subject.replace
+
+      expect(subject.prepared_fixtures).to eq(replaced_fixtures)
+    end
+  end
+
+  describe '#union' do
+    let(:new_fixtures) { 'new fixtures' }
+
+    before do
+      fixtures.stub(:union).and_return(new_fixtures)
+    end
+
+    it 'replaces fixtures' do
+      expect(fixtures).to receive(:union).with(raw_fixtures)
+
+      subject.union
+    end
+
+    it 'cleans fixtures being kept in the fixtures handler' do
+      expect(tmp_keeper).to receive(:clean_fixtures)
+
+      subject.union
+    end
+
+    it 'returns a new container with fixtures' do
+      subject.union
+
+      expect(subject.prepared_fixtures).to eq(new_fixtures)
+    end
+  end
+
+  describe '#exchange' do
+    def exchange
+      subject.exchange(
+        raw_old_fixtures,
+        raw_new_fixtures
+      )
+    end
+
+    shared_examples 'when passed arguments are handled' do
+      it 'handles raw fixtures' do
+        expect(fixtures_handler).to receive(:handle_set_raws).with(
+          expected_raw_old_fixtures,
+          expected_raw_new_fixtures,
+          [home_path_modifier]
+        )
+
+        exchange
+      end
+    end
+
+    let(:fixtures)           { double(exchange: true) }
+    let(:fixtures_handler)   { double }
+    let(:home_path_modifier) { double(modify: true) }
+
+    let(:raw_old_fixtures) { ['old fixtures'] }
+    let(:raw_new_fixtures) { ['new fixtures'] }
+
+    let(:expected_raw_old_fixtures) { raw_old_fixtures }
+    let(:expected_raw_new_fixtures) { raw_new_fixtures }
+
+    let(:old_fixture) { double }
+    let(:new_fixture) { double }
+
+    let(:handled_old_fixtures) { [old_fixture] }
+    let(:handled_new_fixtures) { [new_fixture] }
+
+    before do
+      SPV::Fixtures::Handler.stub(:new).and_return(fixtures_handler)
+      SPV::Fixtures::Modifiers::HomePath.stub(:new).and_return(home_path_modifier)
+
+      fixtures_handler.stub(:handle_set_raws).and_return([
+        handled_old_fixtures,
+        handled_new_fixtures
+      ])
+    end
+
+    it 'initializes the home path modifier' do
+      expect(SPV::Fixtures::Modifiers::HomePath).to receive(:new).with(options)
+
+      exchange
+    end
+
+    context 'when no arrays are passed as arguments' do
+      let(:raw_old_fixtures) { {old_fixtures: 'hash with vcr options'} }
+      let(:raw_new_fixtures) { {new_fixtures: 'hash with vcr options'} }
+
+      let(:expected_raw_old_fixtures) { [raw_old_fixtures] }
+      let(:expected_raw_new_fixtures) { [raw_new_fixtures] }
+
+      it_behaves_like 'when passed arguments are handled'
+    end
+
+    context 'when arrays are passed as arguments' do
+      it_behaves_like 'when passed arguments are handled'
+    end
+
+    it 'exchanges fixtures' do
+      expect(fixtures).to receive(:exchange).with(
+        handled_old_fixtures, handled_new_fixtures
+      )
+
+      exchange
+    end
+  end
+end

data/spec/unit/dsl/initial_adjuster_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe SPV::DSL::InitialAdjuster do
+  let(:options)          { double }
+  let(:tmp_keeper)       { double(add_fixtures: true) }
+  let(:handled_fixtures) { double }
+  let(:fixtures_handler) { double(handle_raw: handled_fixtures) }
+
+  subject { described_class.new(options) }
+
+  before do
+    SPV::Fixtures::TmpKeeper.stub(:new).and_return(tmp_keeper)
+    SPV::Fixtures::Handler.stub(:new).and_return(fixtures_handler)
+  end
+
+  describe '.new' do
+    it 'initializes the fixtures tmp keeper' do
+      expect(SPV::Fixtures::TmpKeeper).to receive(:new).with(options)
+
+      subject
+    end
+
+    it 'initializes the fixtures handler' do
+      expect(SPV::Fixtures::Handler).to receive(:new)
+
+      subject
+    end
+  end
+
+  describe '#fixtures' do
+    let(:raw_fixtures)       { 'some fixtures' }
+    let(:home_path_modifier) { 'some home path modifier' }
+
+    before do
+      SPV::Fixtures::Modifiers::HomePath.stub(:new).and_return(home_path_modifier)
+    end
+
+    it 'initializes the home path modifier' do
+      expect(SPV::Fixtures::Modifiers::HomePath).to receive(:new).with(options)
+
+      subject.fixtures(raw_fixtures)
+    end
+
+    it 'handles raw fixtures' do
+      expect(fixtures_handler).to receive(:handle_raw).with(
+        raw_fixtures,
+        [home_path_modifier]
+      )
+
+      subject.fixtures(raw_fixtures)
+    end
+
+    it 'adds fixtures' do
+      expect(tmp_keeper).to receive(:add_fixtures).with(handled_fixtures)
+
+      subject.fixtures(raw_fixtures)
+    end
+  end
+
+  describe '#home_path' do
+    let(:raw_home_path) { 'some home path' }
+
+    it 'defines a default home path' do
+      expect(options).to receive(:home_path=).with(raw_home_path)
+
+      subject.home_path(raw_home_path)
+    end
+  end
+
+  describe '#path' do
+    def set_path
+      subject.path 'path', raw_fixtures
+    end
+
+    let(:raw_fixtures)       { 'some raw fixtures' }
+    let(:options_with_path)  { double('path=' => true) }
+
+    let(:path_modifier)       { double }
+    let(:home_path_modifier)  { double }
+
+    before do
+      SPV::OptionsWithPath.stub(:new).and_return(options_with_path)
+      SPV::Fixtures::Modifiers::Path.stub(:new).and_return(path_modifier)
+      SPV::Fixtures::Modifiers::HomePath.stub(:new).and_return(home_path_modifier)
+    end
+
+    it 'initializes a new object with options' do
+      expect(SPV::OptionsWithPath).to receive(:new).with(options)
+
+      set_path
+    end
+
+    it 'defines path to fixtures' do
+      expect(options_with_path).to receive(:path=).with('path')
+
+      set_path
+    end
+
+    it 'initializes the modifier to modify path' do
+      expect(
+        SPV::Fixtures::Modifiers::Path
+      ).to receive(:new).with(options_with_path)
+
+      set_path
+    end
+
+    it 'initializes the modifier to set home path' do
+      expect(
+        SPV::Fixtures::Modifiers::HomePath
+      ).to receive(:new).with(options_with_path)
+
+      set_path
+    end
+
+    it 'handles raw fixtures' do
+      expect(fixtures_handler).to receive(:handle_raw).with(
+        raw_fixtures,
+        [
+          path_modifier,
+          home_path_modifier
+        ]
+      )
+
+      set_path
+    end
+
+    it 'adds fixtures into tmp keeper' do
+      expect(tmp_keeper).to receive(:add_fixtures).with(handled_fixtures)
+
+      set_path
+    end
+  end
+
+  describe '#waiter' do
+    let(:options) { double('waiter='.to_sym => true, 'waiter_options='.to_sym => true) }
+
+    it 'defines a new waiter' do
+      expect(options).to receive(:waiter=).with(kind_of(Proc))
+
+      subject.waiter { 'some waiter here' }
+    end
+
+    it 'defines an options for a waiter' do
+      expect(options).to receive(:waiter_options=).with(eject_cassettes: false)
+
+      subject.waiter(eject_cassettes: false) { 'some waiter here' }
+    end
+  end
+
+  describe '#prepared_fixtures' do
+    let(:fixtures)     { double }
+    let(:raw_fixtures) { 'some raw fixtures' }
+
+    before do
+      SPV::Fixtures.stub(:new).and_return(fixtures)
+
+      tmp_keeper.stub(:fixtures).and_return(raw_fixtures)
+    end
+
+    it 'initializes the fixtures handler' do
+      expect(SPV::Fixtures).to receive(:new).with(raw_fixtures).and_return(fixtures)
+
+      expect(subject.prepared_fixtures).to eq(fixtures)
+    end
+  end
+end

data/spec/unit/element_container_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+class TestPageWithElement
+  extend SitePrism::ElementContainer
+
+  class << self
+    def element(*); end
+  end
+
+  def el_with_options
+    'original element with options'
+  end
+
+  def test_el; end
+
+  element_with_vcr(:el_with_options, '#selector', fixtures: 'some fixtures') {}
+end
+
+describe SitePrism::ElementContainer do
+  describe '.element_with_vcr' do
+    it 'calls the original element method with given arguments' do
+      expect(TestPageWithElement).to receive(:element).with(
+        :test_el,
+        '#test_selector',
+        visible: false
+      )
+
+      TestPageWithElement.instance_eval do
+        element_with_vcr :test_el, '#test_selector', visible: false
+      end
+    end
+
+    context 'when a method for getting an element is called' do
+      let(:page)   { TestPageWithElement.new }
+      let(:vcr_el) { 'vcr element' }
+
+      subject { page.el_with_options }
+
+      it 'initializes a new instance of an element with empty options' do
+        expect(SPV::Element).to receive(:new).with(
+          'original element with options', page
+        ).and_return(vcr_el)
+
+        expect(subject).to eq(vcr_el)
+      end
+    end
+  end
+end

data/spec/unit/element_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe SPV::Element do
+  let(:node)    { stub   }
+  let(:parent)  { double }
+  let(:applier) { double(apply: true) }
+
+  before do
+    SPV::Applier.stub(:new).and_return(applier)
+  end
+
+  describe '.new' do
+    it 'initializes the fixtures applier' do
+      expect(SPV::Applier).to receive(:new).with(
+        parent
+      )
+
+      b1 = proc { }
+
+      described_class.new(nil, parent)
+    end
+  end
+
+  describe '#click_and_apply_vcr' do
+    subject { described_class.new(nil, parent) }
+
+    before do
+      subject.stub(:click)
+    end
+
+    it 'applies custom fixtures' do
+      expect(applier).to receive(:apply).with(
+        kind_of(Proc)
+      )
+
+      subject.click_and_apply_vcr() {}
+    end
+
+    it 'clicks on an element' do
+      applier.stub(:apply).and_yield
+
+      expect(subject).to receive(:click)
+
+      subject.click_and_apply_vcr
+    end
+  end
+end

data/spec/unit/fixture_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe SPV::Fixture do
+  describe '#add_path' do
+    subject { described_class.new('some name') }
+
+    it 'have added path to a name of fixture' do
+      subject.add_path('some path/')
+
+      expect(subject.name).to eq('some path/some name')
+    end
+  end
+
+  describe '#set_home_path' do
+    subject { described_class.new('~/fixture_name') }
+
+    it 'defines a new name with replaced home path symbol' do
+      subject.set_home_path('my_home_path/')
+
+      expect(subject.name).to eq('my_home_path/fixture_name')
+    end
+  end
+
+  describe '#has_link_to_home_path?' do
+    it 'returns true when a name of fixture starts with "~/"' do
+      expect(
+        described_class.new('~/some').has_link_to_home_path?
+      ).to be_true
+    end
+
+    it 'returns true when a name of fixture does not start with "~/"' do
+      expect(
+        described_class.new('some').has_link_to_home_path?
+      ).to be_false
+    end
+  end
+
+  describe '#clean_name' do
+    subject { described_class.new('~/fixture_name') }
+
+    it 'returns a name without a home path' do
+      expect(subject.clean_name).to eq('fixture_name')
+    end
+  end
+end

data/spec/unit/fixtures/converter_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe SPV::Fixtures::Converter do
+  describe '.convert_raw' do
+    let(:first_fixture)  { 'test_fixture' }
+    let(:second_fixture) { {fixture: 'fixture_name', options: 'vcr options'} }
+
+    subject {
+      described_class.convert_raw(
+        [first_fixture, second_fixture]
+      )
+    }
+
+    before do
+      SPV::Fixture.stub(:new).and_return('first prepared', 'second prepared')
+    end
+
+    it 'initializes first object of Fixture class' do
+      expect(SPV::Fixture).to receive(:new).with(first_fixture)
+
+      subject
+    end
+
+    it 'initializes second object of Fixture class' do
+      expect(SPV::Fixture).to receive(:new).with(
+        second_fixture[:fixture], second_fixture[:options]
+      )
+
+      subject
+    end
+
+    it 'returns a prepared list of fixtures' do
+      expect(subject).to eq(['first prepared', 'second prepared'])
+    end
+  end
+end

data/spec/unit/fixtures/handler_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe SPV::Fixtures::Handler do
+  let(:options)            { double }
+  let(:converted_fixtures) { [] }
+  let(:fixtures_converter) { SPV::Fixtures::Converter }
+
+  subject { described_class.new(options) }
+
+  before do
+    SPV::Fixtures::Converter.stub(:convert_raw).and_return(converted_fixtures)
+  end
+
+  describe '#handle_raw' do
+    def handle_raw
+      subject.handle_raw(raw_fixtures, [modifier])
+    end
+
+    let(:raw_fixtures)       { 'some raw fixtures' }
+    let(:converted_fixture)  { 'converted fixture' }
+    let(:converted_fixtures) { [converted_fixture] }
+    let(:modifier)           { double(modify: true) }
+
+    it 'converts raw fixtures' do
+      expect(fixtures_converter).to receive(:convert_raw).with(raw_fixtures)
+
+      handle_raw
+    end
+
+    it 'modifies the converted fixtures' do
+      expect(modifier).to receive(:modify).with(converted_fixture)
+
+      handle_raw
+    end
+
+    it 'returns handled fixtures' do
+      expect(handle_raw).to eq(converted_fixtures)
+    end
+  end
+
+  describe '#handle_set_raws' do
+    def handle_set_raws
+      subject.handle_set_raws(raw_fixtures_1, raw_fixtures_2, modifiers)
+    end
+
+    let(:raw_fixtures_1)     { 'raw fixtures #1' }
+    let(:raw_fixtures_2)     { 'raw fixtures #2' }
+    let(:handled_fixtures_1) { 'handled fixtures #1' }
+    let(:handled_fixtures_2) { 'handled fixtures #2' }
+    let(:modifiers)          { 'some modifiers' }
+
+    before do
+      subject.stub(:handle_raw).and_return(handled_fixtures_1, handled_fixtures_2)
+    end
+
+    it 'handles the first set of raw fixtures' do
+      expect(subject).to receive(:handle_raw).with(raw_fixtures_1, modifiers)
+
+      handle_set_raws
+    end
+
+    it 'handles the second set of raw fixtures' do
+      expect(subject).to receive(:handle_raw).with(raw_fixtures_2, modifiers)
+
+      handle_set_raws
+    end
+
+    it 'returns all handled fixtures' do
+      expect(handle_set_raws).to eq([handled_fixtures_1, handled_fixtures_2])
+    end
+  end
+end

data/spec/unit/fixtures/manager_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe SPV::Fixtures::Manager do
+  let(:options) { double(fixtures: ['some fixture']) }
+
+  describe '#inject' do
+    let(:fixture1)    { double(name: 'arya_stark', options: {erb: {testvar: true}}) }
+    let(:fixture2)    { double(name: 'jon_snow', options: {}) }
+    let(:fixtures)    { [fixture1, fixture2] }
+
+    subject(:manager) { described_class.new(options) }
+
+    context 'when there are fixtures' do
+      after do
+        VCR.eject_cassette
+        VCR.eject_cassette
+      end
+
+      it 'VCR holds the first fixture' do
+        manager.inject(fixtures)
+
+        VCR.eject_cassette
+        fixture = VCR.eject_cassette
+
+        expect(fixture.name).to eq('arya_stark')
+        expect(fixture.erb).to eq({testvar: true})
+      end
+
+      it 'VCR holds the second fixture' do
+        manager.inject(fixtures)
+
+        fixture = VCR.eject_cassette
+
+        expect(fixture.name).to eq('jon_snow')
+        expect(fixture.erb).to be_nil
+      end
+    end
+
+    context 'when there are not any fixtures' do
+      it 'raises an error about no fixtures' do
+        expect { manager.inject([]) }.to raise_error(
+          ArgumentError,
+          'No fixtures were specified to insert them into VCR'
+        )
+      end
+    end
+  end
+
+  describe '#eject' do
+    subject { described_class.new(options).eject }
+
+    it 'ejects all fixtures from VCR' do
+      expect(SPV::Helpers).to receive(:eject_all_cassettes)
+
+      subject
+    end
+  end
+end

data/spec/unit/fixtures/modifiers/home_path_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe SPV::Fixtures::Modifiers::HomePath do
+  describe '#modify' do
+    let(:path)    { 'some home path' }
+    let(:options) { double(home_path: path) }
+    let(:fixture) { double(name: 'test_with_home_path', :has_link_to_home_path? => true) }
+
+    subject { described_class.new(options).modify(fixture) }
+
+    context 'when a name of the fixture has a link to the home path' do
+      context 'when the home_path is defined' do
+        it 'writes a proper path to the fixture' do
+          expect(fixture).to receive(:set_home_path).with(path)
+
+          subject
+        end
+      end
+
+      context 'when the home_path is not defined' do
+        before do
+          options.stub(:home_path).and_return(nil)
+        end
+
+        it 'raises an argument error about wrong way of defining fixtures' do
+          msg = 'You are trying to use a home path for test_with_home_path fixture. ' \
+            'Home path cannot be used since it is not defined, please refer to the documentation ' \
+            'to make sure you define the home path properly.'
+
+          expect { subject }.to raise_error(
+            ArgumentError, msg
+          )
+        end
+      end
+    end
+
+    context 'when a name of the fixture has no link to the home path' do
+      let(:fixture) { double(:has_link_to_home_path? => false) }
+
+      it 'does not set any home path' do
+        expect(fixture).to_not receive(:set_home_path)
+
+        subject
+      end
+    end
+  end
+end