howitzer 0.0.3 → 1.0.1

data/spec/unit/lib/utils/locator_store_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+require "#{lib_path}/howitzer/utils/locator_store"
+
+describe "Locator store" do
+  let(:bad_name) { 'name' }
+  let(:error) { LocatorStore::LocatorNotDefinedError }
+
+  shared_examples "locator methods" do |prefix, web_page|
+    describe "#{prefix}locator" do
+      context "when bad locator given" do
+        subject { web_page.locator(bad_name) }
+        it { expect {subject}.to raise_error(error) }
+      end
+      context "when CSS locator given" do
+        before { web_page.add_locator :base_locator, 'base_locator' }
+        subject { web_page.locator(:base_locator) }
+        it { expect(subject).to eq('base_locator') }
+      end
+      context "when XPATH locator given" do
+        before { web_page.add_locator :test_xpath, xpath: "//select[@id='modelOptions']/option[@value='m6']" }
+        subject { web_page.locator(:test_xpath) }
+        it { expect(subject).to eq([:xpath, "//select[@id='modelOptions']/option[@value='m6']"]) }
+      end
+    end
+
+    describe "#{prefix}link_locator" do
+      context "when bad locator given" do
+        subject { web_page.link_locator(bad_name) }
+        it { expect {subject}. to raise_error(error) }
+      end
+      context "when correct locator given" do
+        before { web_page.add_link_locator :link_locator, 'link_locator' }
+        subject { web_page.link_locator(:link_locator) }
+        it { expect(subject).to eq('link_locator') }
+      end
+    end
+
+    describe "#{prefix}field_locator" do
+      context "when bad locator given" do
+        subject { web_page.field_locator(bad_name) }
+        it { expect {subject}. to raise_error(error) }
+      end
+      context "when correct locator given" do
+        before { web_page.add_field_locator :field_locator, 'field_locator' }
+        subject { web_page.field_locator(:field_locator) }
+        it { expect(subject).to eq('field_locator') }
+      end
+    end
+
+    describe "#{prefix}button_locator" do
+      context "when bad locator given" do
+        subject { web_page.button_locator(bad_name) }
+        it { expect {subject}. to raise_error(error) }
+      end
+      context "when correct locator given" do
+        before { web_page.add_button_locator :button_locator, 'button_locator' }
+        subject { web_page.button_locator(:button_locator) }
+        it { expect(subject).to eq('button_locator') }
+      end
+    end
+
+    describe "#{prefix}find_element" do
+      context "when existing locator name given" do
+        context "of base type" do
+          before { web_page.add_locator :test_locator, '.foo' }
+          subject { web_page.find_element(name) }
+          context "as string" do
+            let(:name) { "test_locator" }
+            it do
+              expect(web_page.is_a?(Class) ? web_page : web_page.class).to receive(:find).with('.foo')
+              subject
+            end
+          end
+          context "as symbol" do
+            let(:name) { :test_locator }
+            it do
+              expect(web_page.is_a?(Class) ? web_page : web_page.class).to receive(:find).with('.foo')
+              subject
+            end
+          end
+        end
+        context "when link locator or other" do
+          before { web_page.add_link_locator :test_link_locator, 'foo' }
+          subject { web_page.find_element(:test_link_locator) }
+          it do
+            expect(web_page.is_a?(Class) ? web_page : web_page.class).to receive(:find_link).with('foo')
+            subject
+          end
+        end
+      end
+      context "when not existing locator name" do
+        subject { web_page.find_element(:unknown_locator) }
+        it { expect{ subject }.to raise_error(LocatorStore::LocatorNotDefinedError, "unknown_locator") }
+      end
+    end
+
+    describe "#{prefix}apply" do
+      context "when bad locator given" do
+        before { web_page.add_locator :test_locator,  lambda{|test| test} }
+        let(:locator)  { lambda{|test| test}  }
+        subject { web_page.apply(locator, 'test') }
+        it { expect {subject}.to raise_error(NoMethodError) }
+
+      end
+      context "when correct locator given" do
+        before { web_page.add_locator :test_locator,  lambda{|location_name| {xpath: ".//a[contains(.,'#{location_name}')]"}} }
+        let(:locator) { lambda{|location_name| {xpath: ".//a[contains(.,'#{location_name}')]"}} }
+        subject { web_page.apply(locator, 'Kiev') }
+        it { expect(subject).to eq([:xpath, ".//a[contains(.,'Kiev')]"]) }
+      end
+    end
+  end
+
+  context "Class methods" do
+    it_behaves_like "locator methods", '.', Class.new{ include LocatorStore }
+  end
+
+  context "Instance methods" do
+    it_behaves_like "locator methods", '#', Class.new{ include LocatorStore }.new
+  end
+
+end

data/spec/unit/lib/utils/log_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require "#{lib_path}/howitzer/utils/log"
+include LoggerHelper
+
+describe "Logger" do
+  let(:path) { File.join(log_path,'log.txt') }
+  context "#log" do
+    subject { log }
+    let(:other_log) { Howitzer::Log.instance }
+    it { expect(subject).to be_a_kind_of(Howitzer::Log) }
+    it { expect(subject).to equal(other_log) }
+  end
+
+  context ".print_feature_name" do
+    let(:feature) { 'Some feature' }
+    let(:expected_result) { "*** Feature: SOME FEATURE ***\n"}
+    subject { read_file(path) }
+    before { log.print_feature_name(feature) }
+    after { clear_file(path) }
+    it { expect(subject).to include(expected_result) }
+  end
+
+  context ".settings_as_formatted_text" do
+    let(:formatted_text) { Faker::Lorem.sentence }
+    let(:as_formatted_text) { double() }
+    let(:expected_result) { formatted_text }
+    subject { read_file(path) }
+    before do
+      expect(settings).to receive(:as_formatted_text).and_return(formatted_text)
+      log.settings_as_formatted_text
+    end
+    after { clear_file(path) }
+    it { expect(subject).to include(expected_result) }
+  end
+
+  context ".print_scenario_name" do
+    let(:expected_result) { " => Scenario: Some scenario\n" }
+    let(:scenario) { 'Some scenario' }
+    subject { read_file(path) }
+    before { log.print_scenario_name(scenario) }
+    after { clear_file(path) }
+    it { expect(subject).to include(expected_result) }
+  end
+
+  context ".error" do
+    context "when one argument given" do
+      subject { log.error(*args) }
+      context "when exception given as argument" do
+        let(:args) { [StandardError.new("Exception_error_message")] }
+        it { expect {subject}.to raise_error(StandardError, "Exception_error_message") }
+      end
+      context "when message given as argument" do
+        let(:args) { ["Runtime_error_message"] }
+        it { expect {subject}.to raise_error(RuntimeError, "Runtime_error_message") }
+      end
+      context "when error object given as arg " do
+        let(:error_object) { ErrorObject = StandardError.new }
+        let(:args) { error_object }
+        it { expect {subject}.to raise_error(StandardError) }
+        it { expect(read_file(path)).to include("[ERROR] [StandardError] StandardError") }
+      end
+      context "when number given as arg" do
+        let(:args) { 123 }
+        it { expect {subject}.to raise_error(RuntimeError) }
+      end
+    end
+    context "when two arguments given" do
+      subject { log.error(*args) }
+      context "when given text as first arg and caller as second" do
+        let(:args) { ["Some_text","two_args_caller"] }
+        it { expect {subject}.to raise_error(RuntimeError) }
+        it { expect(read_file(path)).to include("[ERROR] [RuntimeError] Some_text") }
+        it { expect(read_file(path)).to include("two_args_caller") }
+      end
+      context "when given class inherited from Exception as first arg and message as second" do
+        let(:error_class) {SomeError = Class.new(Exception) }
+        let(:args) { [error_class,"some text"] }
+        it { expect { subject }.to raise_error(error_class,"some text") }
+        it { expect(read_file(path)).to include("[ERROR] [SomeError] some text") }
+      end
+      context "when given some class as first arg and (message) as second" do
+        let(:some_class) { SomeClass = Class.new() }
+        let(:args) { [some_class, "some text" ] }
+        it { expect{subject}.to raise_error(RuntimeError) }
+        it { expect(read_file(path)).to include("[ERROR] [RuntimeError] SomeClass\n\tsome text") }
+      end
+      context "when number given as first arg and message as second" do
+        let(:args) { [123, 'some text' ] }
+        it { expect{subject}.to raise_error(RuntimeError) }
+        it { expect(read_file(path)).to include("[ERROR] [RuntimeError] 123\n\tsome text") }
+      end
+      context "when nubmers given as args" do
+        let(:args) { [123,123] }
+        it { expect{subject}.to raise_error(TypeError) }
+      end
+    end
+    context "when three arguments given" do
+      subject { log.error(*args) }
+      context "when NameError given as first arg, message as second and caller as third" do
+        let(:args) { [NameError, "Name_error_text","three_args_caller"] }
+        it { expect {subject}.to raise_error(NameError) }
+        it { expect(read_file(path)).to include("[ERROR] [NameError] Name_error_text") }
+        it { expect(read_file(path)).to include("three_args_caller") }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+require 'spec_helper'
+require "#{lib_path}/howitzer/utils/page_validator"
+
+describe Howitzer::Utils::PageValidator do
+  describe ".validations" do
+    it { expect(subject.validations).to eql({}) }
+  end
+end
+
+describe "PageValidator" do
+  let(:web_page) { Class.new { include Howitzer::Utils::PageValidator }.new }
+  describe "#check_correct_page_loaded" do
+    subject { web_page.check_correct_page_loaded }
+    context "when no validation specified" do
+      it { expect{subject}.to raise_error(Howitzer::Utils::PageValidator::NoValidationError, "No any page validation was found") }
+    end
+    context "when all validation are specified" do
+      before do
+        web_page.class.validates :title, pattern: /Foo/
+        web_page.class.validates :url, pattern: /Foo/
+        web_page.class.validates :element_presence, locator: :test_locator
+      end
+      it do
+        expect(web_page).to receive(:wait_for_url).with(/Foo/).once
+        expect(web_page).to receive(:wait_for_title).with(/Foo/).once
+        expect(web_page).to receive(:find_element).with(:test_locator)
+        subject
+      end
+    end
+  end
+
+  describe ".validates" do
+    subject { web_page.class.validates(name, options)}
+    context "when name = :url" do
+      context "as string" do
+        let(:name) { "url" }
+        context "when options is correct" do
+          context "(as string)" do
+            let(:options) { {"pattern" => /foo/} }
+            it do
+              expect(subject).to be_a(Proc)
+              expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:url]).to eql(subject)
+            end
+          end
+          context "(as symbol)" do
+            let(:options) { {pattern: /foo/} }
+            it do
+              expect(subject).to be_a(Proc)
+              expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:url]).to eql(subject)
+            end
+          end
+        end
+        context "when options is incorrect" do
+          context "(missing pattern)" do
+            let(:options) { {} }
+            it { expect{subject}.to raise_error(Howitzer::Utils::PageValidator::WrongOptionError, "Please specify ':pattern' option as Regexp object") }
+          end
+          context "(string pattern)" do
+            let(:options) { {pattern: "foo"} }
+            it { expect{subject}.to raise_error(Howitzer::Utils::PageValidator::WrongOptionError, "Please specify ':pattern' option as Regexp object") }
+          end
+          context "(not hash)" do
+            let(:options) { "foo" }
+            it { expect{subject}.to raise_error(TypeError, "Expected options to be Hash, actual is 'String'") }
+          end
+        end
+      end
+      context "as symbol" do
+        let(:name) { :url }
+        let(:options) { {pattern: /foo/} }
+        it do
+          expect(subject).to be_a(Proc)
+          expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:url]).to eql(subject)
+        end
+      end
+    end
+    context "when name = :element_presence" do
+      let(:name) { :element_presence }
+      context "when options is correct" do
+        context "(as string)" do
+          let(:options) { {"locator" => 'test_locator'} }
+          it do
+            expect(subject).to be_a(Proc)
+            expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:element_presence]).to eql(subject)
+          end
+        end
+        context "(as symbol)" do
+          let(:options) { {locator: :test_locator} }
+          it do
+            expect(subject).to be_a(Proc)
+            expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:element_presence]).to eql(subject)
+          end
+        end
+      end
+      context "when options is incorrect" do
+        context "(missing locator)" do
+          let(:options) { {} }
+          it { expect{subject}.to raise_error(Howitzer::Utils::PageValidator::WrongOptionError, "Please specify ':locator' option as one of page locator names") }
+        end
+        context "(blank locator name)" do
+          let(:options) { {locator: ""} }
+          it { expect{subject}.to raise_error(Howitzer::Utils::PageValidator::WrongOptionError, "Please specify ':locator' option as one of page locator names") }
+        end
+      end
+    end
+    context "when name = :title" do
+      let(:name) { :title }
+      context "when options is correct" do
+        context "(as string)" do
+          let(:options) { {"pattern" => /foo/} }
+          it do
+            expect(subject).to be_a(Proc)
+            expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:title]).to eql(subject)
+          end
+        end
+        context "(as symbol)" do
+          let(:options) { {pattern: /foo/} }
+          it do
+            expect(subject).to be_a(Proc)
+            expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:title]).to eql(subject)
+          end
+        end
+      end
+      context "when options is incorrect" do
+        context "(missing pattern)" do
+          let(:options) { {} }
+          it { expect{subject}.to raise_error(Howitzer::Utils::PageValidator::WrongOptionError, "Please specify ':pattern' option as Regexp object") }
+        end
+        context "(string pattern)" do
+          let(:options) { {pattern: "foo"} }
+          it { expect{subject}.to raise_error(Howitzer::Utils::PageValidator::WrongOptionError, "Please specify ':pattern' option as Regexp object") }
+        end
+      end
+    end
+    context "when other name" do
+      let(:name) { :unknown }
+      let(:options) { {} }
+      it { expect{subject}.to raise_error(Howitzer::Utils::PageValidator::UnknownValidationName, "unknown 'unknown' validation name") }
+    end
+  end
+
+end

data/spec/unit/lib/web_page_spec.rb

@@ -0,0 +1,250 @@
+require 'spec_helper'
+require "#{lib_path}/howitzer/web_page"
+require "#{lib_path}/howitzer/utils/capybara_settings"
+
+
+describe "WebPage" do
+  describe ".open" do
+    let(:url_value) { "google.com" }
+    let(:retryable) { double }
+    let(:check_correct_page_loaded) { double }
+    let(:other_instance) { WebPage.instance }
+    subject { WebPage.open(url_value) }
+    before do
+      stub_const("WebPage::URL_PATTERN", 'pattern')
+      allow(WebPage.instance).to receive(:check_correct_page_loaded) { true }
+    end
+    it do
+      expect(log).to receive(:info).with("Open WebPage page by 'google.com' url")
+      expect(WebPage).to receive(:retryable) { retryable }
+      expect(subject).to eq(other_instance)
+      subject
+    end
+  end
+
+  describe ".given" do
+    let(:wait_for_url) { double }
+    before do
+      stub_const("WebPage::URL_PATTERN",'pattern')
+      allow(WebPage.instance).to receive(:check_correct_page_loaded) { true }
+    end
+    it do
+      expect(WebPage.given).to be_a_kind_of(WebPage)
+    end
+  end
+
+  describe "#tinymce_fill_in" do
+    subject { WebPage.instance.tinymce_fill_in(name,options) }
+    let(:name) { 'name' }
+    let(:options) { {with: "some content"} }
+    before do
+      allow(WebPage.instance).to receive(:current_url) { "google.com" }
+      allow(settings).to receive(:driver) { driver_name }
+    end
+    context "when correct driver specified" do
+      let(:driver_name) { 'selenium' }
+      let(:page) { double }
+      let(:driver) { double }
+      let(:browser) { double }
+      let(:switch_to) { double }
+      let(:find) { double }
+      let(:native) { double }
+      it do
+        expect(WebPage.instance).to receive(:page).exactly(3).times { page }
+        expect(page).to receive(:driver).ordered { driver }
+        expect(driver).to receive(:browser).ordered { browser }
+        expect(browser).to receive(:switch_to).ordered { switch_to }
+        expect(switch_to).to receive(:frame).with("name_ifr").once
+
+        expect(page).to receive(:find).with(:css, '#tinymce').ordered { find }
+        expect(find).to receive(:native).ordered { native }
+        expect(native).to receive(:send_keys).with("some content").once
+
+        expect(page).to receive(:driver) { driver }
+        expect(driver).to receive(:browser) { browser }
+        expect(browser).to receive(:switch_to) { switch_to }
+        expect(switch_to).to receive(:default_content)
+
+        subject
+      end
+    end
+    context "when incorrect driver specified" do
+      let(:driver_name) { 'ff' }
+      let(:page) { double }
+      it do
+        expect(WebPage.instance).to receive(:page) { page }
+        expect(page).to receive(:execute_script).with("tinyMCE.get('name').setContent('some content')")
+        subject
+      end
+    end
+  end
+  describe "#click_alert_box" do
+    subject { WebPage.instance.click_alert_box(flag_value) }
+    before do
+      allow(settings).to receive(:driver) { driver_name }
+      allow(settings).to receive(:timeout_tiny) { 0 }
+      allow(WebPage.instance).to receive(:current_url) { "google.com" }
+    end
+    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(WebPage.instance).to receive(:page) { page }
+        expect(page).to receive(:driver).ordered { driver }
+        expect(driver).to receive(:browser).ordered { browser }
+        expect(browser).to receive(:switch_to).ordered { switch_to }
+        expect(switch_to).to receive(:alert).ordered { 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(WebPage.instance).to receive(:page) { page }
+        expect(page).to receive(:driver).ordered { driver }
+        expect(driver).to receive(:browser).ordered { browser }
+        expect(browser).to receive(:switch_to).ordered { switch_to }
+        expect(switch_to).to receive(:alert).ordered { 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(WebPage.instance).to receive(:page) { page }
+        expect(page).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(WebPage.instance).to receive(:page) { page }
+        expect(page).to receive(:evaluate_script).with('window.confirm = function() { return false; }')
+        subject
+      end
+    end
+  end
+
+  describe "#js_click" do
+    subject { WebPage.instance.js_click(".some_class") }
+    before do
+      allow(settings).to receive(:timeout_tiny) { 0.1 }
+      allow(WebPage.instance).to receive(:current_url) { "google.com" }
+    end
+    let(:page) { double }
+    it do
+      expect(WebPage.instance).to receive(:page) { page }
+      expect(page).to receive(:execute_script).with("$('.some_class').trigger('click')")
+      subject
+    end
+
+  end
+
+  describe "#wait_for_title" do
+    subject { WebPage.instance.wait_for_title(expected_title) }
+    before do
+      allow(settings).to receive(:timeout_small) { 0.1 }
+      allow(WebPage.instance).to receive(:title) { "title" }
+    end
+    context "when title equals expected title" do
+      let(:expected_title) { "title" }
+      it do
+        expect(subject).to be_true
+      end
+    end
+    context "when title not equals expected title" do
+      let(:expected_title) { "bad title" }
+      let(:error) { WebPage::IncorrectPageError }
+      let(:error_message) { "Current title: title, expected:  bad title" }
+      it { expect{subject}.to raise_error(error,error_message) }
+    end
+  end
+
+  describe "#wait_for_url" do
+    subject { WebPage.instance.wait_for_url(expected_url) }
+    before do
+      allow(settings).to receive(:timeout_small) { 0.1 }
+      allow(WebPage.instance).to receive(:current_url) { "google.com" }
+    end
+    context "when current_url equals expected_url" do
+      let(:expected_url) { "google.com" }
+      it { expect(subject).to be_true }
+    end
+    context "when current_url not equals expected_url" do
+      let(:expected_url) { "bad_url" }
+      let(:error) { WebPage::IncorrectPageError }
+      let(:error_message) { "Current url: google.com, expected:  #{expected_url}"  }
+      it { expect{subject}.to raise_error(error, error_message) }
+    end
+  end
+
+  describe "#reload" do
+    let(:wait_for_url) { double }
+    subject { WebPage.instance.reload }
+    let(:visit) { double }
+    let(:webpage) { double }
+    before do
+      allow(WebPage.instance).to receive(:current_url) { "google.com" }
+      stub_const("WebPage::URL_PATTERN",'pattern')
+      allow(wait_for_url).to receive('pattern').and_return { true }
+    end
+    it do
+      expect(log).to receive(:info) { "Reload 'google.com' " }
+      expect(WebPage.instance).to receive(:visit).with("google.com")
+      subject
+    end
+  end
+
+  describe ".title" do
+    let(:page) { double }
+    subject { WebPage.instance.title }
+    before do
+      allow(WebPage.instance).to receive(:current_url) { "google.com" }
+    end
+    it do
+      expect(WebPage.instance).to receive(:page) { page }
+      expect(page).to receive(:title)
+      subject
+    end
+  end
+
+  describe ".current_url" do
+    let(:page) { double }
+    subject { WebPage.current_url }
+    it do
+      expect(WebPage).to receive(:page) { page }
+      expect(page).to receive(:current_url) { "google.com" }
+      expect(subject).to eq("google.com")
+    end
+  end
+
+  describe ".text" do
+    let(:page) { double }
+    let(:find) { double }
+    subject { WebPage.text }
+    it do
+      expect(WebPage).to receive(:page) { page }
+      expect(page).to receive(:find).with('body') { find }
+      expect(find).to receive(:text) { "some body text" }
+      expect(subject).to eq("some body text")
+    end
+  end
+end