howitzer 2.1.1 → 2.4.0

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

@@ -1,203 +0,0 @@
-require 'spec_helper'
-require 'howitzer/web/page'
-
-RSpec.describe Howitzer::Web::IframeDsl do
-  let(:fb_page_class) do
-    Class.new(Howitzer::Web::Page) do
-      section :navbar, :xpath, './body' do
-        element :like_button, '#foo_id'
-      end
-    end
-  end
-  let(:nested_class) do
-    module Foo
-      Class.new(Howitzer::Web::Page) do
-        section :navbar, :xpath, './body' do
-          element :like_button, '#foo_id'
-        end
-      end
-    end
-  end
-  let(:double_nested_class) do
-    module Foo
-      module Bar
-        Class.new(Howitzer::Web::Page) do
-          section :navbar, :xpath, './body' do
-            element :like_button, '#foo_id'
-          end
-        end
-      end
-    end
-  end
-
-  let(:web_page_class) do
-    Class.new(Howitzer::Web::Page)
-  end
-
-  before do
-    allow_any_instance_of(fb_page_class).to receive(:check_validations_are_defined!)
-    allow_any_instance_of(web_page_class).to receive(:check_validations_are_defined!)
-    stub_const('FbPage', fb_page_class)
-    stub_const('Foo::FbPage', nested_class)
-    stub_const('Foo::Bar::FbHomePage', double_nested_class)
-    allow(Howitzer::Web::Page).to receive(:descendants) { [FbPage, Foo::FbPage, Foo::Bar::FbHomePage] }
-  end
-
-  describe '.iframe' do
-    context 'when selector is integer' do
-      subject do
-        web_page_class.class_eval do
-          iframe :fb, 1
-        end
-        web_page_class
-      end
-
-      it 'should create public :fb_iframe instance method' do
-        expect(subject.instance.public_methods(false)).to include(:fb_iframe)
-      end
-      it 'should create public :has_fb_iframe? instance method' do
-        expect(subject.instance.public_methods(false)).to include(:has_fb_iframe?)
-      end
-      it 'should create public :has_no_fb_iframe? instance method' do
-        expect(subject.instance.public_methods(false)).to include(:has_no_fb_iframe?)
-      end
-      it 'should be protected class method' do
-        expect { subject.iframe :bar }.to raise_error(NoMethodError)
-        expect(subject.protected_methods(true)).to include(:iframe)
-      end
-    end
-
-    context 'when selector is not specified' do
-      subject do
-        web_page_class.class_eval do
-          iframe :fb
-        end
-        web_page_class
-      end
-
-      it 'should raise error' do
-        expect { subject }.to raise_error(ArgumentError, 'iframe selector arguments must be specified')
-      end
-    end
-
-    context 'when class defined explicity' do
-      subject do
-        web_page_class.class_eval do
-          iframe :fb, FbPage, 1
-        end
-        web_page_class
-      end
-      it 'should find page class specified' do
-        expect(subject).to eql(web_page_class)
-      end
-    end
-
-    context 'when frame nested in module' do
-      subject do
-        web_page_class.class_eval do
-          iframe :foo_fb, 1
-        end
-        web_page_class
-      end
-      it 'should find page class nested in module' do
-        expect(subject).to eql(web_page_class)
-      end
-    end
-
-    context 'when frame nested in module nested in module' do
-      subject do
-        web_page_class.class_eval do
-          iframe :foo_bar_fb_home, 1
-        end
-        web_page_class
-      end
-      it 'should find class nested in modules' do
-        expect(subject).to eql(web_page_class)
-      end
-    end
-  end
-
-  include_examples :capybara_context_holder
-
-  describe 'dynamic_methods' do
-    let(:web_page_object) { web_page_class.instance }
-    let(:kontext) { double(:kontext) }
-    before do
-      allow(Capybara).to receive(:current_session) { kontext }
-    end
-    after { subject }
-
-    describe '#name_iframe' do
-      let(:block) { proc {} }
-      context 'when no options' do
-        subject { web_page_object.fb_iframe(&block) }
-        before { web_page_class.class_eval { iframe :fb, 'foo' } }
-        it do
-          expect(kontext).to receive(:within_frame)
-            .with('foo') { |&block| block.call }
-          expect(block).to receive(:call).with(fb_page_class.instance)
-          expect(fb_page_class).to receive(:displayed?).with(no_args)
-        end
-      end
-      context 'when all possible options' do
-        subject { web_page_object.fb_iframe(wait: 10, text: 'new', &block) }
-        before { web_page_class.class_eval { iframe :fb, :xpath, './/foo', match: :first, text: 'origin' } }
-        it do
-          expect(kontext).to receive(:within_frame)
-            .with(:xpath, './/foo', match: :first, wait: 10, text: 'new') { |&block| block.call }
-          expect(block).to receive(:call).with(fb_page_class.instance)
-          expect(fb_page_class).to receive(:displayed?).with(no_args)
-        end
-      end
-    end
-    describe '#has_name_iframe?' do
-      subject { web_page_object.has_fb_iframe?(wait: 1, text: 'new') }
-      context 'when first argument is integer' do
-        before { web_page_class.class_eval { iframe :fb, 1, match: :first, text: 'origin' } }
-        it do
-          expect(kontext).to receive(:has_selector?)
-            .with('iframe:nth-of-type(2)', match: :first, wait: 1, text: 'new')
-        end
-      end
-      context 'when first argument is string' do
-        before { web_page_class.class_eval { iframe :fb, 'loko', match: :first, text: 'origin' } }
-        it { expect(kontext).to receive(:has_selector?).with(:frame, 'loko', match: :first, wait: 1, text: 'new') }
-      end
-      context 'when first argument is hash' do
-        before { web_page_class.class_eval { iframe :fb, name: 'loko', match: :first, text: 'origin' } }
-        it do
-          expect(kontext).to receive(:has_selector?)
-            .with(:frame, name: 'loko', match: :first, wait: 1, text: 'new')
-        end
-      end
-      context 'when first argument is symbol' do
-        before { web_page_class.class_eval { iframe :fb, :xpath, './/foo', match: :first, text: 'origin' } }
-        it { expect(kontext).to receive(:has_selector?).with(:xpath, './/foo', match: :first, wait: 1, text: 'new') }
-      end
-    end
-    describe '#has_no_name_iframe?' do
-      subject { web_page_object.has_no_fb_iframe?(wait: 1, text: 'new') }
-      context 'when first argument is integer' do
-        before { web_page_class.class_eval { iframe :fb, 1, match: :first, text: 'origin' } }
-        it do
-          expect(kontext).to receive(:has_no_selector?)
-            .with('iframe:nth-of-type(2)', match: :first, wait: 1, text: 'new')
-        end
-      end
-      context 'when first argument is string' do
-        before { web_page_class.class_eval { iframe :fb, 'loko', match: :first, text: 'origin' } }
-        it { expect(kontext).to receive(:has_no_selector?).with(:frame, 'loko', match: :first, wait: 1, text: 'new') }
-      end
-      context 'when first argument is hash' do
-        before { web_page_class.class_eval { iframe :fb, name: 'loko', match: :first, text: 'origin' } }
-        it do
-          expect(kontext).to receive(:has_no_selector?).with(:frame, name: 'loko', match: :first, wait: 1, text: 'new')
-        end
-      end
-      context 'when first argument is symbol' do
-        before { web_page_class.class_eval { iframe :fb, :xpath, './/foo', match: :first, text: 'origin' } }
-        it { expect(kontext).to receive(:has_no_selector?).with(:xpath, './/foo', match: :first, wait: 1, text: 'new') }
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-require 'spec_helper'
-require 'howitzer/web/page_dsl'
-
-RSpec.describe Howitzer::Web::PageDsl do
-  let(:page) { Class.new { include Howitzer::Web::PageDsl } }
-
-  describe '.on' do
-    subject { page.on { 1 } }
-    before { expect(Howitzer::Web::PageDsl::PageScope).to receive(:new).with(page) }
-    it { is_expected.to be_nil }
-  end
-end
-
-RSpec.describe Howitzer::Web::PageDsl::PageScope do
-  let(:fake_page) { double }
-  let(:page) { Class.new }
-  before { allow(page).to receive(:given) { fake_page } }
-
-  describe '.new' do
-    subject { described_class.new(page) { bar } }
-    before { expect_any_instance_of(described_class).to receive(:bar).with(no_args) { true } }
-    it { is_expected.to be_a(described_class) }
-  end
-
-  describe '#is_expected' do
-    let(:scope) { described_class.new(page) { 1 } }
-    subject { scope.is_expected }
-    before { expect(scope).to receive(:expect).with(fake_page) { true } }
-    it { is_expected.to eq(true) }
-  end
-
-  describe '#method_missing' do
-    context 'when starts with be_' do
-      let(:scope) { described_class.new(page) { 1 } }
-      subject { scope.be_a(described_class) }
-      it { expect(subject.class).to eq(RSpec::Matchers::BuiltIn::BeAKindOf) }
-    end
-
-    context 'when starts with have_' do
-      let(:scope) { described_class.new(page) { 1 } }
-      subject { scope.have_content(described_class) }
-      it { expect(subject.class).to eq(RSpec::Matchers::BuiltIn::Has) }
-    end
-
-    context 'when out' do
-      let(:outer_context) do
-        Class.new do
-          def initialize(klass)
-            @klass = klass
-            @a = 5
-          end
-
-          def scope
-            @klass.new(nil) { 1 }
-          end
-
-          def secret
-            '***'
-          end
-        end
-      end
-      let(:scope) { outer_context.new(described_class).scope }
-      it { expect(scope.out(:@a)).to eq(5) }
-      it { expect(scope.out(:secret)).to eq('***') }
-    end
-
-    context 'when starts other prefix' do
-      let(:scope) { described_class.new(page) { 1 } }
-      subject { scope.foo(1, 2, 3) }
-      before { expect(fake_page).to receive(:foo).with(1, 2, 3) { true } }
-      it { is_expected.to eq(true) }
-    end
-  end
-end

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

@@ -1,378 +0,0 @@
-require 'spec_helper'
-require 'howitzer/web/page'
-require 'howitzer/web/blank_page'
-
-RSpec.describe Howitzer::Web::Page do
-  let(:session) { double(:session) }
-  before { allow(Capybara).to receive(:current_session) { session } }
-  describe '.open' do
-    let(:retryable) { double }
-    let(:check_correct_page_loaded) { double }
-    let(:other_instance) { described_class.instance }
-
-    context 'when custom user_agent specified' do
-      let(:url_value) { 'http://example.com/users' }
-      let(:driver) { double }
-      subject { described_class.open(validate: false) }
-      before do
-        allow(Howitzer).to receive(:user_agent) { 'user_agent' }
-        allow(described_class).to receive(:retryable)
-        allow(described_class).to receive(:expanded_url)
-        allow(Howitzer::Log).to receive(:info)
-      end
-      context 'with webkit driver' do
-        before { allow(Howitzer).to receive(:driver) { 'webkit' } }
-        it do
-          expect(Capybara).to receive_message_chain(:current_session, :driver) { driver }
-          expect(driver).to receive(:header).with('User-Agent', Howitzer.user_agent)
-          subject
-        end
-      end
-      context 'with poltergeist driver' do
-        before { allow(Howitzer).to receive(:driver) { 'poltergeist' } }
-        it do
-          expect(Capybara).to receive_message_chain(:current_session, :driver) { driver }
-          expect(driver).to receive(:add_headers).with('User-Agent' => Howitzer.user_agent)
-          subject
-        end
-      end
-    end
-
-    context 'when validate missing' do
-      context 'when params present' do
-        let(:url_value) { 'http://example.com/users/1' }
-        subject { described_class.open(id: 1) }
-        it do
-          expect(described_class).to receive(:expanded_url).with({ id: 1 }, nil) { url_value }.once.ordered
-          expect(Howitzer::Log).to receive(:info)
-            .with("Open #{described_class} page by '#{url_value}' url").once.ordered
-          expect(described_class).to receive(:retryable).ordered.once.and_call_original
-          expect(session).to receive(:visit).with(url_value).once.ordered
-          expect(described_class).to receive(:given).once.ordered.and_return(true)
-          expect(subject).to eq(true)
-        end
-      end
-      context 'when custom processor specified' do
-        let(:custom_processor) { double }
-        let(:url_value) { 'http://example.com/users/1' }
-        subject { described_class.open(id: 1, url_processor: custom_processor) }
-        it do
-          expect(described_class).to receive(:expanded_url).with({ id: 1 }, custom_processor) { url_value }.once.ordered
-          expect(Howitzer::Log).to receive(:info)
-            .with("Open #{described_class} page by '#{url_value}' url").once.ordered
-          expect(described_class).to receive(:retryable).ordered.once.and_call_original
-          expect(session).to receive(:visit).with(url_value).once.ordered
-          expect(described_class).to receive(:given).once.ordered.and_return(true)
-          expect(subject).to eq(true)
-        end
-      end
-      context 'when params missing' do
-        let(:url_value) { 'http://example.com/users' }
-        subject { described_class.open }
-        it do
-          expect(described_class).to receive(:expanded_url).with({}, nil).and_return(url_value).once.ordered
-          expect(Howitzer::Log).to receive(:info)
-            .with("Open #{described_class} page by '#{url_value}' url").once.ordered
-          expect(described_class).to receive(:retryable).ordered.once.and_call_original
-          expect(session).to receive(:visit).with(url_value).once.ordered
-          expect(described_class).to receive(:given).once.ordered.and_return(true)
-          expect(subject).to eq(true)
-        end
-      end
-    end
-    context 'when validate: false' do
-      let(:url_value) { 'http://example.com/users' }
-      subject { described_class.open(validate: false) }
-      it do
-        expect(described_class).to receive(:expanded_url).with({}, nil).and_return(url_value).once.ordered
-        expect(Howitzer::Log).to receive(:info).with("Open #{described_class} page by '#{url_value}' url").once.ordered
-        expect(described_class).to receive(:retryable).ordered.once.and_call_original
-        expect(session).to receive(:visit).with(url_value).once.ordered
-        expect(described_class).not_to receive(:given)
-        expect(subject).to be_nil
-      end
-    end
-    context 'when validate: true with params' do
-      let(:url_value) { 'http://example.com/users/1' }
-      subject { described_class.open(validate: true, id: 1) }
-      it do
-        expect(described_class).to receive(:expanded_url).with({ id: 1 }, nil).and_return(url_value).once.ordered
-        expect(Howitzer::Log).to receive(:info).with("Open #{described_class} page by '#{url_value}' url").once.ordered
-        expect(described_class).to receive(:retryable).ordered.once.and_call_original
-        expect(session).to receive(:visit).with(url_value).once.ordered
-        expect(described_class).to receive(:given).once.ordered.and_return(true)
-        expect(subject).to eq(true)
-      end
-    end
-  end
-
-  describe '.given' do
-    subject { described_class.given }
-    before do
-      expect(described_class).to receive(:displayed?).with(no_args).once
-      expect(described_class).to receive(:instance).and_return(true)
-    end
-    it { is_expected.to be_truthy }
-  end
-
-  describe '.title' do
-    let(:page) { double }
-    subject { described_class.instance.title }
-    before do
-      allow_any_instance_of(described_class).to receive(:check_validations_are_defined!).and_return(true)
-      allow(session).to receive(:current_url).and_return('google.com')
-    end
-    it do
-      expect(session).to receive(:title)
-      subject
-    end
-  end
-
-  describe '.current_page' do
-    subject { described_class.current_page }
-    context 'when matched_pages has no pages' do
-      before { allow(described_class).to receive(:matched_pages).and_return([]) }
-      it { is_expected.to eq(described_class::UnknownPage) }
-    end
-    context 'when matched_pages has more than 1 page' do
-      let(:foo_page) { double(inspect: 'FooPage') }
-      let(:bar_page) { double(inspect: 'BarPage') }
-      before do
-        allow_any_instance_of(described_class).to receive(:check_validations_are_defined!).and_return(true)
-        allow(session).to receive(:current_url).and_return('http://test.com')
-        allow(session).to receive(:title) { 'Test site' }
-        allow(described_class).to receive(:matched_pages).and_return([foo_page, bar_page])
-      end
-      it do
-        expect { subject }.to raise_error(
-          Howitzer::AmbiguousPageMatchingError,
-          "Current page matches more that one page class (FooPage, BarPage).\n" \
-          "\tCurrent url: http://test.com\n\tCurrent title: Test site"
-        )
-      end
-    end
-    context 'when matched_pages has only 1 page' do
-      let(:foo_page) { double(to_s: 'FooPage') }
-      before { allow(described_class).to receive(:matched_pages).and_return([foo_page]) }
-      it { is_expected.to eq(foo_page) }
-    end
-  end
-
-  describe '.displayed?' do
-    subject { described_class.displayed? }
-    context 'when page is opened' do
-      before { allow(described_class).to receive(:opened?).and_return(true) }
-      it { is_expected.to eq(true) }
-    end
-    context 'when page is not opened' do
-      before do
-        allow(described_class).to receive(:current_page).and_return('FooPage')
-        allow(session).to receive(:current_url).and_return('http://test.com')
-        allow(session).to receive(:title).and_return('Test site')
-        allow(described_class).to receive(:opened?).and_return(false)
-      end
-      it do
-        expect { subject }.to raise_error(
-          Howitzer::IncorrectPageError,
-          "Current page: FooPage, expected: #{described_class}.\n" \
-          "\tCurrent url: http://test.com\n\tCurrent title: Test site"
-        )
-      end
-    end
-  end
-
-  describe '.current_url' do
-    before { allow(Capybara).to receive_message_chain(:current_session, :current_url).and_return('http://example.com') }
-    it 'should return current url page' do
-      expect(Howitzer::Web::Page.current_url).to eq('http://example.com')
-    end
-  end
-
-  describe '.site' do
-    let!(:base_class) do
-      Class.new(described_class) do
-        site 'https://base.com'
-      end
-    end
-    let!(:child_class1) do
-      Class.new(base_class) do
-        site 'https://child.com'
-      end
-    end
-    let!(:child_class2) do
-      Class.new(base_class)
-    end
-    let!(:child_class3) do
-      Class.new(described_class)
-    end
-    it { expect(described_class.send(:site_value)).to eq('http://login:pass@my.website.com') }
-    it { expect(base_class.send(:site_value)).to eq('https://base.com') }
-    it { expect(child_class1.send(:site_value)).to eq('https://child.com') }
-    it { expect(child_class2.send(:site_value)).to eq('https://base.com') }
-    it { expect(child_class3.send(:site_value)).to eq('http://login:pass@my.website.com') }
-    it 'should be protected' do
-      expect { described_class.site('http://example.com') }.to raise_error(NoMethodError)
-    end
-  end
-
-  describe '.expanded_url' do
-    context 'when default url processor' do
-      context 'when params present' do
-        subject { test_page.expanded_url(id: 1) }
-        context 'when page url specified' do
-          context 'when BlankPage' do
-            let(:test_page) { Howitzer::Web::BlankPage }
-            it { is_expected.to eq('about:blank') }
-          end
-          context 'when other page' do
-            let(:test_page) do
-              Class.new(described_class) do
-                site 'http://example.com'
-                path '/users{/id}'
-              end
-            end
-            it { is_expected.to eq('http://example.com/users/1') }
-          end
-          context 'when root not specified' do
-            let(:test_page) do
-              Class.new(described_class) do
-                path '/users{/id}'
-              end
-            end
-            it { is_expected.to eq('http://login:pass@my.website.com/users/1') }
-          end
-        end
-      end
-      context 'when custom url processor' do
-        let(:test_page) do
-          Class.new(described_class) do
-            site 'http://example.com'
-            path '/users{/id}'
-          end
-        end
-        let(:custom_processor_class) do
-          Class.new do
-            def self.restore(_name, value)
-              value.tr('-', ' ')
-            end
-
-            def self.match(_name)
-              '.*'
-            end
-
-            def self.validate(_name, value)
-              !(value =~ /^[\w ]+$/).nil?
-            end
-
-            def self.transform(_name, value)
-              value.tr(' ', '+')
-            end
-          end
-        end
-        subject { test_page.expanded_url({ id: 'hello world' }, custom_processor_class) }
-        it { is_expected.to eq('http://example.com/users/hello+world') }
-      end
-      context 'when page url missing' do
-        subject { described_class.expanded_url }
-        it do
-          expect { subject }.to raise_error(
-            ::Howitzer::NoPathForPageError,
-            "Please specify path for '#{described_class}' page. Example: path '/home'"
-          )
-        end
-      end
-    end
-    context 'when params missing' do
-      let(:test_page) do
-        Class.new(described_class) do
-          site 'http://example.com'
-          path '/users'
-        end
-      end
-      subject { test_page.expanded_url }
-      it { is_expected.to eq('http://example.com/users') }
-    end
-  end
-
-  describe '.path' do
-    subject { described_class.send(:path, value) }
-    before { subject }
-    context 'when value is number' do
-      let(:value) { 1 }
-      it do
-        expect(described_class.send(:path_value)).to eql '1'
-        expect(described_class.private_methods(true)).to include(:path_value)
-      end
-    end
-    context 'when value is string' do
-      let(:value) { '/users' }
-      it do
-        expect(described_class.send(:path_value)).to eql '/users'
-      end
-    end
-  end
-
-  describe '#initialize' do
-    subject { described_class.send(:new) }
-    before do
-      expect_any_instance_of(described_class).to receive(:check_validations_are_defined!).once.and_return(true)
-    end
-    context 'when maximized_window is true' do
-      let(:driver) { double }
-      before { allow(Howitzer).to receive(:maximized_window) { true } }
-      it do
-        expect_any_instance_of(described_class).to receive_message_chain('current_window.maximize')
-        subject
-      end
-    end
-    context 'when maximized_window is true and driver is headless_chrome' do
-      before do
-        allow(Howitzer).to receive(:maximized_window) { true }
-        allow(Capybara).to receive(:current_driver) { 'headless_chrome' }
-      end
-      it do
-        expect_any_instance_of(described_class).not_to receive('current_window.maximize')
-        subject
-      end
-    end
-    context 'when maximized_window is false' do
-      before { allow(Howitzer).to receive(:maximized_window) { false } }
-      it do
-        expect_any_instance_of(described_class).not_to receive('current_window.maximize')
-        subject
-      end
-    end
-  end
-
-  describe 'inherited callback' do
-    let(:page_class) { Class.new(described_class) }
-    it 'can not be instantiated with new' do
-      expect { page_class.new }.to raise_error(NoMethodError, "private method `new' called for #{page_class}")
-    end
-  end
-
-  describe '#reload' do
-    let(:wait_for_url) { double }
-    subject { described_class.instance.reload }
-    let(:visit) { double }
-    before do
-      allow(session).to receive(:current_url).and_return('google.com')
-    end
-    it do
-      expect(Howitzer::Log).to receive(:info).and_return("Reload 'google.com'")
-      expect(session).to receive(:visit).with('google.com')
-      subject
-    end
-  end
-
-  describe '#capybara_context' do
-    subject { described_class.instance.capybara_context }
-    before { expect(Capybara).to receive(:current_session).and_return(:context) }
-    it { is_expected.to eq(:context) }
-  end
-
-  describe 'includes proxied capybara methods' do
-    let(:reciever) { described_class.instance }
-    include_examples :capybara_methods_proxy
-  end
-end