howitzer 1.1.1 → 2.0.0

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

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

@@ -0,0 +1,304 @@
+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 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) { 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 { 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({}) { 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 { 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({}) { 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) { 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 { 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) { 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!) { true }
+      allow(session).to receive(:current_url) { '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) { [] } }
+      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!) { true }
+        allow(session).to receive(:current_url) { 'http://test.com' }
+        allow(session).to receive(:title) { 'Test site' }
+        allow(described_class).to receive(:matched_pages) { [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) { [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?) { true } }
+      it { is_expected.to eq(true) }
+    end
+    context 'when page is not opened' do
+      before do
+        allow(described_class).to receive(:current_page) { 'FooPage' }
+        allow(session).to receive(:current_url) { 'http://test.com' }
+        allow(session).to receive(:title) { 'Test site' }
+        allow(described_class).to receive(:opened?) { 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) { '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(:app_host)).to eq('http://login:pass@my.website.com') }
+    it { expect(base_class.send(:app_host)).to eq('https://base.com') }
+    it { expect(child_class1.send(:app_host)).to eq('https://child.com') }
+    it { expect(child_class2.send(:app_host)).to eq('https://base.com') }
+    it { expect(child_class3.send(:app_host)).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 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
+      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 { expect(described_class.instance_variable_get(:@path_template)).to eq('1') }
+    end
+    context 'when value is string' do
+      let(:value) { '/users' }
+      it { expect(described_class.instance_variable_get(:@path_template)).to eq('/users') }
+    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 { 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 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) }
+    context 'when abstract class without validations' do
+      let!(:page_class) do
+        Howitzer::Web::PageValidator.instance_variable_set(:@pages, [])
+        Class.new(described_class)
+      end
+      it { expect(Howitzer::Web::PageValidator.pages).to eq([]) }
+    end
+    context 'when class has validations' do
+      let!(:page_class) do
+        allow(described_class).to receive(:validations) { { title: /some text/ } }
+        Howitzer::Web::PageValidator.instance_variable_set(:@pages, [])
+        Class.new(described_class)
+      end
+      it { expect(Howitzer::Web::PageValidator.pages).to eq([page_class]) }
+    end
+    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) { 'google.com' }
+    end
+    it do
+      expect(Howitzer::Log).to receive(:info) { "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) { :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

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

@@ -0,0 +1,218 @@
+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
+      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, :test_locator
+        end
+        it { expect { subject }.to_not raise_error }
+      end
+
+      context 'when lambda selector' do
+        before do
+          web_page.class.validate :element_presence, :test_locator, 'some_text'
+        end
+        it { expect { subject }.to_not raise_error }
+      end
+    end
+  end
+
+  describe '.validate' do
+    before do
+      described_class.validations[web_page.class.name] = 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.name][:url]).to be_a Proc
+          end
+        end
+        context '(as symbol)' do
+          let(:value) { /foo/ }
+          it do
+            is_expected.to be_a(Proc)
+            expect(described_class.validations[web_page.class.name][: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.name][:url]).to be_a Proc
+        end
+      end
+    end
+    context 'when name = :element_presence' do
+      let(:name) { :element_presence }
+      context '(as string)' do
+        let(:value) { 'test_locator' }
+        let(:additional_value) { 'some string' }
+        it do
+          is_expected.to be_a(Proc)
+          expect(described_class.validations[web_page.class.name][:element_presence]).to eql(subject)
+        end
+      end
+      context '(as symbol)' do
+        let(:value) { :test_locator }
+        it do
+          is_expected.to be_a(Proc)
+          expect(described_class.validations[web_page.class.name][:element_presence]).to eql(subject)
+        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.name][:title]).to be_a Proc
+        end
+      end
+      context '(as symbol)' do
+        let(:value) { /foo/ }
+        it do
+          is_expected.to be_a(Proc)
+          expect(described_class.validations[web_page.class.name][: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 '.pages' do
+    subject { described_class.pages }
+    it do
+      expect(subject).not_to include(Symbol)
+      subject << Symbol
+      expect(subject).to include(Symbol)
+    end
+  end
+
+  describe '.opened?' do
+    subject { web_page_class.opened? }
+    context 'when no one validation is defined' do
+      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
+      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) { 'http://test.com/foo' }
+          allow(web_page_class.instance).to receive(:title) { 'Foo page' }
+          allow(web_page_class).to receive(:has_login_element?).with(no_args) { 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 { 'http://test.com/bar' }
+          expect(web_page_class.instance).to receive(:title).never
+          allow(web_page_class).to receive(:has_login_element?).with(no_args).never
+        end
+        it { is_expected.to be_falsey }
+      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
+        def self.name
+          'TestWebPage1Class'
+        end
+
+        def self.opened?
+          true
+        end
+      end
+    end
+
+    let!(:web_page2_class) do
+      Class.new do
+        include Howitzer::Web::PageValidator
+        def self.name
+          'TestWebPage2Class'
+        end
+
+        def self.opened?
+          false
+        end
+      end
+    end
+    subject { web_page2_class.matched_pages }
+    before { described_class.instance_variable_set(:@pages, [web_page1_class, web_page2_class]) }
+    it { is_expected.to eq([web_page1_class]) }
+  end
+end