howitzer 2.1.1 → 2.4.0

data/spec/unit/lib/web/page_validator_spec.rb

@@ -1,276 +0,0 @@
-require 'spec_helper'
-require 'howitzer/web/page_validator'
-require 'howitzer/web/element_dsl'
-
-RSpec.describe Howitzer::Web::PageValidator do
-  describe '.validations' do
-    it { expect(subject.validations).to be_a(Hash) }
-  end
-
-  let(:web_page_class) do
-    Class.new do
-      include Howitzer::Web::ElementDsl
-      include Howitzer::Web::PageValidator
-      element :foo, 'a'
-      element :bar, :xpath, ->(v) { v }
-      def self.name
-        'TestWebPageClass'
-      end
-    end
-  end
-  let(:web_page) { web_page_class.new }
-  describe '#check_validations_are_defined!' do
-    subject { web_page.check_validations_are_defined! }
-    context 'when no validation specified' do
-      it do
-        expect { subject }.to raise_error(
-          Howitzer::NoValidationError,
-          "No any page validation was found for 'TestWebPageClass' page"
-        )
-      end
-    end
-    context 'when title validation is specified' do
-      before do
-        web_page.class.validate :title, /Foo/
-      end
-      it { expect { subject }.to_not raise_error }
-    end
-    context 'when url validation is specified' do
-      before do
-        web_page.class.validate :url, /Foo/
-      end
-      it { expect { subject }.to_not raise_error }
-    end
-    context 'when element_presence validation is specified' do
-      context 'when simple selector' do
-        before do
-          web_page.class.validate :element_presence, :foo
-        end
-        it { expect { subject }.to_not raise_error }
-      end
-
-      context 'when lambda selector' do
-        before do
-          web_page.class.validate :element_presence, :bar, 'some_text'
-        end
-        it { expect { subject }.to_not raise_error }
-      end
-    end
-  end
-
-  describe '.validate' do
-    before do
-      described_class.validations[web_page.class] = nil
-    end
-    let(:additional_value) { nil }
-    subject { web_page.class.validate(name, *[value, additional_value].compact) }
-    context 'when name = :url' do
-      context 'as string' do
-        let(:name) { 'url' }
-        context '(as string)' do
-          let(:value) { 'foo' }
-          it do
-            is_expected.to be_a(Proc)
-            expect(described_class.validations[web_page.class][:url]).to be_a Proc
-          end
-        end
-        context '(as regexp)' do
-          let(:value) { /foo/ }
-          it do
-            is_expected.to be_a(Proc)
-            expect(described_class.validations[web_page.class][:url]).to be_a Proc
-          end
-        end
-      end
-      context 'as symbol' do
-        let(:name) { :url }
-        let(:value) { /foo/ }
-        it do
-          is_expected.to be_a(Proc)
-          expect(described_class.validations[web_page.class][:url]).to be_a Proc
-        end
-      end
-    end
-    context 'when name = :element_presence' do
-      let(:name) { :element_presence }
-      context '(as string)' do
-        let(:value) { 'bar' }
-        let(:additional_value) { 'some string' }
-        it do
-          is_expected.to be_a(Proc)
-          expect(described_class.validations[web_page.class][:element_presence]).to eql(subject)
-        end
-      end
-      context '(as symbol)' do
-        let(:value) { :foo }
-        it do
-          is_expected.to be_a(Proc)
-          expect(described_class.validations[web_page.class][:element_presence]).to eql(subject)
-        end
-      end
-
-      context 'when refers to unknown element' do
-        let(:value) { :unknown }
-        it do
-          subject
-          expect do
-            described_class.validations[web_page.class][:element_presence].call(web_page, false)
-          end.to raise_error(
-            Howitzer::UndefinedElementError,
-            ":element_presence validation refers to undefined 'unknown' element on 'TestWebPageClass' page."
-          )
-        end
-      end
-    end
-    context 'when name = :title' do
-      let(:name) { :title }
-      context '(as string)' do
-        let(:value) { 'foo' }
-        it do
-          is_expected.to be_a(Proc)
-          expect(described_class.validations[web_page.class][:title]).to be_a Proc
-        end
-      end
-      context '(as regexp)' do
-        let(:value) { /foo/ }
-        it do
-          is_expected.to be_a(Proc)
-          expect(described_class.validations[web_page.class][:title]).to be_a Proc
-        end
-      end
-    end
-    context 'when other name' do
-      let(:name) { :unknown }
-      let(:value) { '' }
-      it do
-        expect { subject }.to raise_error(Howitzer::UnknownValidationError, "unknown 'unknown' validation type")
-      end
-    end
-  end
-
-  describe '.opened?' do
-    context 'when no one validation is defined' do
-      subject { web_page_class.opened? }
-      it do
-        expect { subject }.to raise_error(
-          Howitzer::NoValidationError,
-          "No any page validation was found for 'TestWebPageClass' page"
-        )
-      end
-    end
-    context 'when all validations are defined' do
-      context 'when sync is default' do
-        subject { web_page_class.opened? }
-        before do
-          web_page_class.class_eval do
-            include Singleton
-            element :login, '#id'
-            validate :url, /foo/
-            validate :title, /Foo page/
-            validate :element_presence, :login
-          end
-        end
-        context 'when all matches' do
-          before do
-            allow(web_page_class.instance).to receive(:current_url).and_return('http://test.com/foo')
-            allow(web_page_class.instance).to receive(:has_title?).and_return('Foo page')
-            allow(web_page_class.instance).to receive(:has_login_element?).with(no_args).and_return(true)
-          end
-          it { is_expected.to be_truthy }
-        end
-        context 'when first validation fails' do
-          before do
-            expect(web_page_class.instance).to receive(:current_url).once.and_return('http://test.com/bar')
-            expect(web_page_class.instance).to receive(:has_title?).never
-            allow(web_page_class).to receive(:has_login_element?).with(no_args).never
-          end
-          it { is_expected.to be_falsey }
-        end
-      end
-
-      context 'when sync is true' do
-        subject { web_page_class.opened?(sync: true) }
-        before do
-          web_page_class.class_eval do
-            include Singleton
-            element :login, '#id'
-            validate :url, /foo/
-            validate :title, /Foo page/
-            validate :element_presence, :login
-          end
-        end
-        context 'when all matches' do
-          before do
-            allow(web_page_class.instance).to receive(:current_url).and_return('http://test.com/foo')
-            allow(web_page_class.instance).to receive(:has_title?).and_return('Foo page')
-            allow(web_page_class.instance).to receive(:has_login_element?).with(no_args).and_return(true)
-          end
-          it { is_expected.to be_truthy }
-        end
-        context 'when first validation fails' do
-          before do
-            expect(web_page_class.instance).to receive(:current_url).once.and_return('http://test.com/bar')
-            expect(web_page_class.instance).to receive(:has_title?).never
-            allow(web_page_class).to receive(:has_login_element?).with(no_args).never
-          end
-          it { is_expected.to be_falsey }
-        end
-      end
-
-      context 'when sync is false' do
-        subject { web_page_class.opened?(sync: false) }
-        before do
-          web_page_class.class_eval do
-            include Singleton
-            element :login, '#id'
-            validate :url, /foo/
-            validate :title, /Foo page/
-            validate :element_presence, :login
-          end
-        end
-        context 'when all matches' do
-          before do
-            allow(web_page_class.instance).to receive(:current_url).and_return('http://test.com/foo')
-            allow(web_page_class.instance).to receive(:title).and_return('Foo page')
-            allow(web_page_class.instance).to receive(:has_no_login_element?).with(no_args).and_return(false)
-          end
-          it { is_expected.to be_truthy }
-        end
-        context 'when first validation fails' do
-          before do
-            expect(web_page_class.instance).to receive(:current_url).once.and_return('http://test.com/bar')
-            expect(web_page_class.instance).to receive(:title).never
-            allow(web_page_class).to receive(:has_no_login_element?).with(no_args).never
-          end
-          it { is_expected.to be_falsey }
-        end
-      end
-    end
-  end
-
-  describe 'web_page.validations' do
-    it { expect(web_page_class.validations).to be_a(Hash) }
-  end
-
-  describe '#matched_pages' do
-    let!(:web_page1_class) do
-      Class.new do
-        include Howitzer::Web::PageValidator
-      end
-    end
-    let!(:web_page2_class) do
-      Class.new do
-        include Howitzer::Web::PageValidator
-      end
-    end
-    subject { web_page2_class.matched_pages }
-    before do
-      allow(Howitzer::Web::PageValidator).to receive(:validations).with(no_args) do
-        { web_page1_class => 1, web_page2_class => 2 }
-      end
-      expect(web_page1_class).to receive(:opened?).with(sync: false).and_return(true)
-      expect(web_page2_class).to receive(:opened?).with(sync: false).and_return(false)
-    end
-    it { is_expected.to eq([web_page1_class]) }
-  end
-end

data/spec/unit/lib/web/section_dsl_spec.rb

@@ -1,165 +0,0 @@
-require 'spec_helper'
-require 'howitzer/web/section'
-
-RSpec.describe Howitzer::Web::SectionDsl do
-  let(:section_class) do
-    Class.new(Howitzer::Web::Section) do
-      me :xpath, './/div'
-    end
-  end
-  let(:web_page_class) do
-    Class.new do
-      include Howitzer::Web::SectionDsl
-
-      def capybara_context
-        Capybara.current_session
-      end
-    end
-  end
-  before { stub_const('FooSection', section_class) }
-  describe '.section' do
-    subject do
-      web_page_class.class_eval do
-        section :foo
-      end
-      web_page_class
-    end
-
-    it 'should create public :foo_section instance method' do
-      expect(subject.new.public_methods(false)).to include(:foo_section)
-    end
-    it 'should create public :foo_sections instance method' do
-      expect(subject.new.public_methods(false)).to include(:foo_sections)
-    end
-    it 'should create public :has_foo_section? instance method' do
-      expect(subject.new.public_methods(false)).to include(:has_foo_section?)
-    end
-    it 'should create public :has_no_foo_section? instance method' do
-      expect(subject.new.public_methods(false)).to include(:has_no_foo_section?)
-    end
-    it 'should be protected class method' do
-      expect { subject.section :bar }.to raise_error(NoMethodError)
-      expect(subject.protected_methods(true)).to include(:section)
-    end
-  end
-
-  describe 'Dsl on section' do
-    let(:other_section_class) do
-      Class.new(Howitzer::Web::Section) do
-        me '#id'
-        element :baz, '.klass'
-      end
-    end
-    let(:parent) { double }
-    let(:capybara_context) { double }
-    let(:nested_capybara_context) { double }
-    let(:capybara_element) { double }
-    subject { section_class.new(parent, capybara_context) }
-    before do
-      stub_const('BarSection', other_section_class)
-      section_class.class_eval do
-        section :bar
-      end
-      expect(capybara_context).to receive(:find).with('#id').at_least(:once) { nested_capybara_context }
-      expect(nested_capybara_context).to receive(:find).with('.klass') { capybara_element }
-    end
-    it 'can work with nested section' do
-      expect(subject.bar_section).to be_a(other_section_class)
-      expect(subject.bar_section.private_methods(false)).to include(:baz_element)
-      expect(subject.bar_section.send(:baz_element)).to eq(capybara_element)
-    end
-  end
-
-  describe 'Dsl on page' do
-    let(:session) { double(:session) }
-    before do
-      allow(Capybara).to receive(:current_session) { session }
-    end
-    context 'when section with single argument without block' do
-      let(:finder_args) { [:xpath, './/div'] }
-      let(:section_name) { :foo }
-      before do
-        web_page_class.class_eval do
-          section :foo
-        end
-      end
-      include_examples :dynamic_section_methods
-    end
-
-    context 'when section with single argument and block' do
-      subject do
-        web_page_class.class_eval do
-          section :unknown do
-            element :some, :id, 'do_do'
-          end
-        end
-      end
-      it 'should generate error' do
-        expect { subject }.to raise_error(ArgumentError, 'Missing finder arguments')
-      end
-    end
-
-    context 'when section with 2 arguments without block' do
-      let(:finder_args) { ['.some_class'] }
-      let(:section_name) { :foo }
-      before do
-        web_page_class.class_eval do
-          section :foo, '.some_class'
-        end
-      end
-      include_examples :dynamic_section_methods
-    end
-
-    context 'when section with 2 arguments and block' do
-      let(:finder_args) { [:xpath, './/div'] }
-      let(:section_name) { :unknown }
-      let(:section_class) { Howitzer::Web::BaseSection }
-      before do
-        web_page_class.class_eval do
-          section :unknown, :xpath, './/div' do
-            element :some, :id, 'do_do'
-          end
-        end
-      end
-      include_examples :dynamic_section_methods
-    end
-
-    context 'when nested section with 2 arguments and block' do
-      let(:finder_args) { [:xpath, './/div'] }
-      let(:section_name) { :name1 }
-      let(:section_class) { Howitzer::Web::BaseSection }
-      before do
-        web_page_class.class_eval do
-          section :name1, :xpath, './/div' do
-            element :some1, :id, 'do_do'
-
-            section :name2, '#klass' do
-              element :some2, :xpath, './/a'
-            end
-          end
-        end
-      end
-
-      include_examples :dynamic_section_methods
-      include_examples :capybara_context_holder
-
-      context 'checking nested level' do
-        let(:context2) { double }
-        let(:context3) { double }
-        let(:capybara_element) { double }
-        before do
-          expect(session).to receive(:find).with(*finder_args).once.and_return(context2)
-          expect(context2).to receive(:find).with('#klass').and_return(context3)
-          expect(context3).to receive(:find).with(:xpath, './/a').and_return(capybara_element)
-        end
-
-        it 'can work with nested section' do
-          nested_section = web_page_class.new.name1_section.name2_section
-          expect(nested_section).to be_a(section_class)
-          expect(nested_section.private_methods(false)).to include(:some2_element)
-          expect(nested_section.send(:some2_element)).to eq(capybara_element)
-        end
-      end
-    end
-  end
-end

data/spec/unit/lib/web/section_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-require 'howitzer/web/section_dsl'
-require 'howitzer/web/section'
-RSpec.describe Howitzer::Web::Section do
-  describe 'element dsl methods' do
-    let(:parent) { double }
-    let(:capybara_context) { double }
-
-    let(:klass) { Class.new(described_class) }
-    let(:klass_object) { klass.new(parent, capybara_context) }
-
-    it 'returns correct capybara context' do
-      expect(klass_object.capybara_context).to eq(capybara_context)
-    end
-
-    include_examples :element_dsl
-  end
-
-  describe 'DSL' do
-    describe '.me' do
-      let(:section_class) { Class.new(described_class) }
-      context 'when args missing' do
-        it { expect { section_class.send(:me) }.to raise_error(ArgumentError, 'Finder arguments are missing') }
-      end
-
-      context 'when args present' do
-        subject { section_class.send(:me, '.foo') }
-        it { is_expected.to eq(['.foo']) }
-      end
-
-      it 'should be private' do
-        expect { section_class.me('.foo') }.to raise_error(NoMethodError)
-      end
-    end
-  end
-
-  describe '.default_finder_args' do
-    context 'by default' do
-      subject { described_class.default_finder_args }
-      it { is_expected.to be_nil }
-    end
-
-    context 'when defined via dsl' do
-      let(:section_class) do
-        Class.new(described_class) do
-          me :xpath, './/div'
-        end
-      end
-      subject { section_class.default_finder_args }
-      it { is_expected.to eq([:xpath, './/div']) }
-    end
-  end
-
-  describe '#parent' do
-    subject { described_class.new(:test, 1).parent }
-    it { is_expected.to eq(:test) }
-  end
-
-  describe '#capybara_context' do
-    subject { described_class.new(1, :test).capybara_context }
-    it { is_expected.to eq(:test) }
-  end
-end

data/spec/unit/version_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Howitzer do
-  it { expect(subject.constants).to include(:VERSION) }
-  it 'should contains VERSION constant with correct format' do
-    expect(Howitzer::VERSION).to match(/^\d+\.\d+(\.\d+)?$/)
-  end
-end