howitzer 2.2.0 → 2.5.0

data/spec/support/shared_examples/capybara_methods_proxy.rb

@@ -1,94 +0,0 @@
-require 'spec_helper'
-
-RSpec.shared_examples :capybara_methods_proxy do
-  let(:session) { double(:session) }
-  before do
-    allow(Capybara).to receive(:current_session) { session }
-    allow(Howitzer).to receive(:driver) { driver_name }
-    allow(session).to receive(:current_url) { 'google.com' }
-  end
-
-  describe '#driver' do
-    it 'should proxy #driver method' do
-      expect(session).to receive(:driver).once
-      reciever.driver
-    end
-  end
-
-  describe '#text' do
-    it 'should proxy #text method' do
-      expect(session).to receive(:text).once
-      reciever.text
-    end
-  end
-
-  context 'when capybara session method' do
-    it 'should proxy method' do
-      expect(session).to receive(:visit).once
-      reciever.visit
-    end
-  end
-
-  context 'when capybara modal method' do
-    it 'should proxy method' do
-      expect(session).to receive(:dismiss_prompt).with(:some_text).once
-      reciever.dismiss_prompt(:some_text)
-    end
-  end
-
-  describe '#click_alert_box' do
-    subject { reciever.click_alert_box(flag_value) }
-    context 'when flag true and correct driver specified' do
-      let(:flag_value) { true }
-      let(:page) { double }
-      let(:alert) { double }
-      let(:driver) { double }
-      let(:browser) { double }
-      let(:switch_to) { double }
-      let(:driver_name) { 'selenium' }
-      it do
-        expect(session).to receive(:driver).ordered.and_return(driver)
-        expect(driver).to receive(:browser).ordered.and_return(browser)
-        expect(browser).to receive(:switch_to).ordered.and_return(switch_to)
-        expect(switch_to).to receive(:alert).ordered.and_return(alert)
-        expect(alert).to receive(:accept).once
-        subject
-      end
-    end
-    context 'when flag false and correct driver specified' do
-      let(:flag_value) { false }
-      let(:page) { double }
-      let(:alert) { double }
-      let(:driver) { double }
-      let(:browser) { double }
-      let(:switch_to) { double }
-      let(:driver_name) { 'selenium' }
-      it do
-        expect(session).to receive(:driver).ordered.and_return(driver)
-        expect(driver).to receive(:browser).ordered.and_return(browser)
-        expect(browser).to receive(:switch_to).ordered.and_return(switch_to)
-        expect(switch_to).to receive(:alert).ordered.and_return(alert)
-        expect(alert).to receive(:dismiss).once
-        subject
-      end
-    end
-    context 'when flag true and wrong driver specified' do
-      let(:flag_value) { true }
-      let(:page) { double }
-      let(:driver_name) { 'ff' }
-      it do
-        expect(session).to receive(:evaluate_script).with('window.confirm = function() { return true; }')
-        subject
-      end
-    end
-    context 'when flag false and wrong driver specified' do
-      let(:driver_name) { 'ff' }
-      let(:flag_value) { false }
-      let(:page) { double }
-      it do
-        expect(session).to receive(:evaluate_script).with('window.confirm = function() { return false; }')
-        subject
-      end
-    end
-  end
-end

data/spec/support/shared_examples/dynamic_section_methods.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-RSpec.shared_examples :dynamic_section_methods do
-  let(:web_page_object) { web_page_class.new }
-
-  describe '#name_section' do
-    let(:capybara_element) { double }
-    subject { web_page_object.send("#{section_name}_section") }
-    before { expect(session).to receive(:find).with(*finder_args).once.and_return(capybara_element) }
-    it { is_expected.to be_a(section_class) }
-  end
-  describe '#name_sections' do
-    subject { web_page_object.send("#{section_name}_sections") }
-    let(:capybara_element1) { double }
-    let(:capybara_element2) { double }
-    before do
-      expect(session).to receive(:all).with(*finder_args).once.and_return([capybara_element1, capybara_element2])
-    end
-    it 'should return collection of sections' do
-      res = subject
-      expect(res.size).to eq(2)
-      expect(res.first).to be_a(section_class)
-      expect(res.last).to be_a(section_class)
-    end
-  end
-  describe '#has_name_section?' do
-    subject { web_page_object.send("has_#{section_name}_section?") }
-    before { expect(session).to receive(:has_selector?).with(*finder_args).once.and_return(true) }
-    it { is_expected.to eq(true) }
-  end
-  describe '#has_no_name_element?' do
-    subject { web_page_object.send("has_no_#{section_name}_section?") }
-    before { expect(session).to receive(:has_no_selector?).with(*finder_args).once.and_return(true) }
-    it { is_expected.to eq(true) }
-  end
-end

data/spec/support/shared_examples/element_dsl.rb

@@ -1,242 +0,0 @@
-require 'spec_helper'
-
-RSpec.shared_examples :element_dsl do
-  describe '.element' do
-    context 'when regular capybara params' do
-      before do
-        klass.class_eval do
-          element :foo, :xpath, '//a'
-        end
-      end
-      it 'should create private :foo_element instance method' do
-        expect(klass_object.private_methods(false)).to include(:foo_element)
-      end
-      it 'should create private :foo_elements instance method' do
-        expect(klass_object.private_methods(false)).to include(:foo_elements)
-      end
-      it 'should create private :wait_for_foo_element instance method' do
-        expect(klass_object.private_methods(false)).to include(:wait_for_foo_element)
-      end
-      it 'should create public :has_foo_element? instance method' do
-        expect(klass_object.public_methods(false)).to include(:has_foo_element?)
-      end
-      it 'should create public :has_no_foo_element? instance method' do
-        expect(klass_object.public_methods(false)).to include(:has_no_foo_element?)
-      end
-      it 'should be protected class method' do
-        expect { klass.element :bar }.to raise_error(NoMethodError)
-        expect(klass.protected_methods(true)).to include(:element)
-      end
-    end
-    context 'when 1 param is proc' do
-      before do
-        klass.class_eval do
-          element :foo, :xpath, ->(title) { "//a[.='#{title}']" }
-        end
-      end
-      it 'should create private :foo_element instance method' do
-        expect(klass_object.private_methods(false)).to include(:foo_element)
-      end
-      it 'should create private :foo_elements instance method' do
-        expect(klass_object.private_methods(false)).to include(:foo_elements)
-      end
-      it 'should create private :wait_for_foo_element instance method' do
-        expect(klass_object.private_methods(false)).to include(:wait_for_foo_element)
-      end
-      it 'should create public :has_foo_element? instance method' do
-        expect(klass_object.public_methods(false)).to include(:has_foo_element?)
-      end
-      it 'should create public :has_no_foo_element? instance method' do
-        expect(klass_object.public_methods(false)).to include(:has_no_foo_element?)
-      end
-      it 'should be protected class method' do
-        expect { klass.element :bar }.to raise_error(NoMethodError)
-        expect(klass.protected_methods(true)).to include(:element)
-      end
-    end
-    context 'when 2 params are proc' do
-      subject do
-        klass.class_eval do
-          element :foo, -> { puts 1 }, ->(title) { "//a[.='#{title}']" }
-        end
-      end
-      it 'should generate error' do
-        expect { subject.element :bar }.to raise_error(
-          Howitzer::BadElementParamsError,
-          'Using more than 1 proc in arguments is forbidden'
-        )
-      end
-    end
-  end
-
-  describe 'dynamic_methods' do
-    let(:web_page_object) { web_page_class.new }
-    let(:kontext) { double(:kontext) }
-    before do
-      allow(Capybara).to receive(:current_session) { kontext }
-      klass.class_eval do
-        element :foo, :xpath,
-                ->(title, name) { "//a[.='#{title}']/*[@name='#{name}']" }, text: 'original', match: :first
-        element :bar, '.someclass', text: 'origin', match: :first
-        element :top_panel, '.top', text: 'origin', match: :first
-      end
-    end
-
-    describe '#name_element' do
-      context 'when simple selector' do
-        subject { klass_object.send(:bar_element, text: 'new', wait: 10) }
-        after { subject }
-        it do
-          expect(klass_object.capybara_context).to receive(:find)
-            .with('.someclass', wait: 10, text: 'new', match: :first)
-        end
-      end
-      context 'when lambda selector' do
-        subject { klass_object.send(:foo_element, 'Hello', 'super', text: 'new', wait: 10) }
-        after { subject }
-        it do
-          expect(klass_object.capybara_context).to receive(:find)
-            .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
-        end
-
-        context 'when several execution with different data' do
-          it 'does not cache previous data' do
-            expect(klass_object.capybara_context).to receive(:find)
-              .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first).at_least(:once)
-            klass_object.send(:foo_element, 'Hello', 'super', text: 'new', wait: 10)
-
-            expect(klass_object.capybara_context).to receive(:find)
-              .with(:xpath, "//a[.='Bye']/*[@name='puper']", wait: 15, text: 'new', match: :first).at_least(:once)
-            klass_object.send(:foo_element, 'Bye', 'puper', text: 'new', wait: 15)
-          end
-        end
-      end
-    end
-    describe '#name_elements' do
-      after { subject }
-      context 'when simple selector' do
-        subject { klass_object.send(:bar_elements, text: 'new', wait: 10) }
-        it do
-          expect(klass_object.capybara_context).to receive(:all)
-            .with('.someclass', wait: 10, text: 'new', match: :first)
-        end
-      end
-      context 'when lambda selector' do
-        subject { klass_object.send(:foo_elements, 'Hello', 'super', text: 'new', wait: 10) }
-        it do
-          expect(
-            klass_object.capybara_context
-          ).to receive(:all).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
-        end
-      end
-    end
-    describe '#wait_for_name_element' do
-      context 'when simple selector' do
-        subject { klass_object.send(:wait_for_bar_element, text: 'new', wait: 10) }
-        it do
-          expect(klass_object.capybara_context).to receive(:find)
-            .with('.someclass', wait: 10, text: 'new', match: :first)
-          is_expected.to eq(nil)
-        end
-      end
-      context 'when lambda selector' do
-        subject { klass_object.send(:wait_for_foo_element, 'Hello', 'super', text: 'new', wait: 10) }
-        it do
-          expect(
-            klass_object.capybara_context
-          ).to receive(:find).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
-          is_expected.to eq(nil)
-        end
-      end
-    end
-    describe '#within_name_element' do
-      let(:within_scope) { double }
-      after { subject }
-      context 'not nested' do
-        context 'when simple selector' do
-          subject do
-            klass_object.instance_eval do
-              within_bar_element(wait: 5, text: 'new') do
-                foo_element('Hello', 'super', wait: 10, text: 'new')
-              end
-            end
-          end
-          it do
-            expect(klass_object.capybara_context).to receive(:find)
-              .with('.someclass', wait: 5, text: 'new', match: :first) { within_scope }
-            expect(within_scope).to receive(:find)
-              .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
-          end
-        end
-        context 'when lambda selector' do
-          subject do
-            klass_object.instance_eval do
-              within_foo_element('Hello', 'super', wait: 10, text: 'new') do
-                bar_element(wait: 10, text: 'new')
-              end
-            end
-          end
-          it do
-            expect(klass_object.capybara_context).to receive(:find)
-              .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first) { within_scope }
-            expect(within_scope).to receive(:find).with('.someclass', wait: 10, text: 'new', match: :first)
-          end
-        end
-      end
-      context 'nested' do
-        let(:nested_within_scope) { double }
-        subject do
-          klass_object.instance_eval do
-            within_top_panel_element(wait: 10, text: 'new') do
-              within_bar_element(wait: 10, text: 'new') do
-                foo_element('Hello', 'super', wait: 10, text: 'new')
-              end
-            end
-          end
-        end
-        it do
-          expect(klass_object.capybara_context).to receive(:find)
-            .with('.top', wait: 10, text: 'new', match: :first) { within_scope }
-          expect(within_scope).to receive(:find)
-            .with('.someclass', wait: 10, text: 'new', match: :first) { nested_within_scope }
-          expect(nested_within_scope).to receive(:find)
-            .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
-        end
-      end
-    end
-    describe '#has_name_element?' do
-      after { subject }
-      context 'when simple selector' do
-        subject { klass_object.send(:has_bar_element?, wait: 10, text: 'new') }
-        it do
-          expect(klass_object.capybara_context).to receive(:has_selector?)
-            .with('.someclass', wait: 10, text: 'new', match: :first)
-        end
-      end
-      context 'when lambda selector' do
-        subject { klass_object.send(:has_foo_element?, 'Hello', 'super', wait: 10, text: 'new') }
-        it do
-          expect(klass_object.capybara_context).to receive(:has_selector?)
-            .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
-        end
-      end
-    end
-    describe '#has_no_name_element?' do
-      after { subject }
-      context 'when simple selector' do
-        subject { klass_object.send(:has_no_bar_element?, wait: 10, text: 'new') }
-        it do
-          expect(klass_object.capybara_context).to receive(:has_no_selector?)
-            .with('.someclass', wait: 10, text: 'new', match: :first)
-        end
-      end
-      context 'when lambda selector' do
-        subject { klass_object.send(:has_no_foo_element?, 'Hello', 'super', wait: 10, text: 'new', match: :first) }
-        it do
-          expect(klass_object.capybara_context).to receive(:has_no_selector?)
-            .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
-        end
-      end
-    end
-  end
-end

data/spec/support/shared_examples/meta_highlight_xpath.rb

@@ -1,41 +0,0 @@
-RSpec.shared_examples :meta_highlight_xpath do
-  let(:element) { described_class.new(name, context) }
-  describe '#xpath' do
-    let(:capybara_element) { double }
-    context 'when element is found' do
-      before { allow(element).to receive(:capybara_element) { capybara_element } }
-      it do
-        expect(capybara_element).to receive(:path)
-        element.xpath
-      end
-    end
-    context 'when element is blank' do
-      before { allow(element).to receive(:capybara_element) {} }
-      it do
-        expect(capybara_element).not_to receive(:path)
-        element.xpath
-      end
-    end
-  end
-
-  describe '#highlight' do
-    context 'when xpath blank' do
-      before { allow(element).to receive(:xpath) { nil } }
-      it do
-        expect(Howitzer::Log).to receive(:debug).with("Element #{name} not found on the page")
-        expect(context).not_to receive(:execute_script)
-        element.highlight
-      end
-    end
-    context 'when xpath is present' do
-      before { allow(element).to receive(:xpath) { '//a' } }
-      it do
-        expect(context).to receive(:execute_script).with(
-          "document.evaluate('//a', document, null, XPathResult.FIRST_ORDERED_NODE_TYPE,"\
-                             ' null).singleNodeValue.style.border = "thick solid red"'
-        )
-        element.highlight
-      end
-    end
-  end
-end