howitzer 1.0.2 → 1.1.0

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

@@ -2,27 +2,27 @@ require 'spec_helper'
 require 'howitzer/utils/log'
 include LoggerHelper
 
-describe "Logger" do
+RSpec.describe 'Logger' do
   let(:path) { File.join(log_path,'log.txt') }
-  context "#log" do
+  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) }
+    it { is_expected.to be_a_kind_of(Howitzer::Log) }
+    it { is_expected.to equal(other_log) }
   end
 
-  context ".print_feature_name" do
+  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) }
+    it { is_expected.to include(expected_result) }
   end
 
-  context ".settings_as_formatted_text" do
-    let(:formatted_text) { Faker::Lorem.sentence }
-    let(:as_formatted_text) { double() }
+  context '.settings_as_formatted_text' do
+    let(:formatted_text) { FFaker::Lorem.sentence }
+    let(:as_formatted_text) { double }
     let(:expected_result) { formatted_text }
     subject { read_file(path) }
     before do
@@ -30,77 +30,77 @@ describe "Logger" do
       log.settings_as_formatted_text
     end
     after { clear_file(path) }
-    it { expect(subject).to include(expected_result) }
+    it { is_expected.to include(expected_result) }
   end
 
-  context ".print_scenario_name" do
+  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) }
+    it { is_expected.to include(expected_result) }
   end
 
-  context ".error" do
-    context "when one argument given" do
+  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") }
+      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") }
+      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
+      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") }
+        it { expect(read_file(path)).to include('[ERROR] [StandardError] StandardError') }
       end
-      context "when number given as arg" do
+      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
+    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"] }
+      context 'when given text as first arg and caller as second' do
+        let(:args) { %w(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") }
+        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
+      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") }
+        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" ] }
+      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
+      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
+      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
+    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"] }
+      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") }
+        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

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

@@ -1,14 +1,14 @@
 require 'spec_helper'
-require "howitzer/utils/page_validator"
-require "howitzer/utils/locator_store"
+require 'howitzer/utils/page_validator'
+require 'howitzer/utils/locator_store'
 
-describe Howitzer::Utils::PageValidator do
-  describe ".validations" do
+RSpec.describe Howitzer::Utils::PageValidator do
+  describe '.validations' do
     it { expect(subject.validations).to eql({}) }
   end
 end
 
-describe "PageValidator" do
+RSpec.describe 'PageValidator' do
   let(:web_page_class) do
     Class.new do
       include LocatorStore
@@ -19,35 +19,35 @@ describe "PageValidator" do
     end
   end
   let(:web_page) { web_page_class.new }
-  describe "#check_validations_are_defined!" do
+  describe '#check_validations_are_defined!' do
     subject { web_page.check_validations_are_defined! }
-    context "when no validation specified" do
+    context 'when no validation specified' do
       it do
         expect(log).to receive(:error).with(Howitzer::NoValidationError, "No any page validation was found for 'TestWebPageClass' page").once.and_call_original
         expect { subject }.to raise_error(Howitzer::NoValidationError)
       end
     end
-    context "when old validation style is using" do
-      before { web_page_class.const_set("URL_PATTERN",/Foo/) }
-      after { web_page_class.send :remove_const, "URL_PATTERN"}
+    context 'when old validation style is using' do
+      before { web_page_class.const_set('URL_PATTERN',/Foo/) }
+      after { web_page_class.send :remove_const, 'URL_PATTERN' }
       it do
-        expect(web_page_class).to receive(:validates).with(:url, pattern: /Foo/).and_return{ Howitzer::Utils::PageValidator.validations['TestWebPageClass'] = {}}
+        expect(web_page_class).to receive(:validates).with(:url, pattern: /Foo/){ Howitzer::Utils::PageValidator.validations['TestWebPageClass'] = {}}
         expect{subject}.to_not raise_error
       end
     end
-    context "when title validation is specified" do
+    context 'when title validation is specified' do
       before do
         web_page.class.validates :title, pattern: /Foo/
       end
       it { expect{subject}.to_not raise_error }
     end
-    context "when url validation is specified" do
+    context 'when url validation is specified' do
       before do
         web_page.class.validates :url, pattern: /Foo/
       end
       it { expect{subject}.to_not raise_error }
     end
-    context "when element_presence validation is specified" do
+    context 'when element_presence validation is specified' do
       before do
         web_page.class.validates :element_presence, locator: :test_locator
       end
@@ -55,88 +55,88 @@ describe "PageValidator" do
     end
   end
 
-  describe ".validates" do
+  describe '.validates' do
     before do
       Howitzer::Utils::PageValidator.validations[web_page.class.name] = nil
     end
     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/} }
+    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)
+              is_expected.to be_a(Proc)
               expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:url]).to be_a Proc
             end
           end
-          context "(as symbol)" do
+          context '(as symbol)' do
             let(:options) { {pattern: /foo/} }
             it do
-              expect(subject).to be_a(Proc)
+              is_expected.to be_a(Proc)
               expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:url]).to be_a Proc
             end
           end
         end
-        context "when options is incorrect" do
-          context "(missing pattern)" do
+        context 'when options is incorrect' do
+          context '(missing pattern)' do
             let(:options) { {} }
             it do
               expect(log).to receive(:error).with(Howitzer::WrongOptionError, "Please specify ':pattern' option as Regexp object").once.and_call_original
               expect { subject }.to raise_error(Howitzer::WrongOptionError)
             end
           end
-          context "(string pattern)" do
-            let(:options) { {pattern: "foo"} }
+          context '(string pattern)' do
+            let(:options) { {pattern: 'foo'} }
             it do
               expect(log).to receive(:error).with(Howitzer::WrongOptionError, "Please specify ':pattern' option as Regexp object").once.and_call_original
               expect { subject }.to raise_error(Howitzer::WrongOptionError)
             end
           end
-          context "(not hash)" do
-            let(:options) { "foo" }
+          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
+      context 'as symbol' do
         let(:name) { :url }
         let(:options) { {pattern: /foo/} }
         it do
-          expect(subject).to be_a(Proc)
+          is_expected.to be_a(Proc)
           expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:url]).to be_a Proc
         end
       end
     end
-    context "when name = :element_presence" do
+    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'} }
+      context 'when options is correct' do
+        context '(as string)' do
+          let(:options) { {'locator' => 'test_locator'} }
           it do
-            expect(subject).to be_a(Proc)
+            is_expected.to be_a(Proc)
             expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:element_presence]).to eql(subject)
           end
         end
-        context "(as symbol)" do
+        context '(as symbol)' do
           let(:options) { {locator: :test_locator} }
           it do
-            expect(subject).to be_a(Proc)
+            is_expected.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
+      context 'when options is incorrect' do
+        context '(missing locator)' do
           let(:options) { {} }
           it do
             expect(log).to receive(:error).with(Howitzer::WrongOptionError, "Please specify ':locator' option as one of page locator names").once.and_call_original
             expect { subject }.to raise_error(Howitzer::WrongOptionError)
           end
         end
-        context "(blank locator name)" do
-          let(:options) { {locator: ""} }
+        context '(blank locator name)' do
+          let(:options) { {locator: ''} }
           it do
             expect(log).to receive(:error).with(Howitzer::WrongOptionError, "Please specify ':locator' option as one of page locator names").once.and_call_original
             expect { subject }.to raise_error(Howitzer::WrongOptionError)
@@ -144,34 +144,34 @@ describe "PageValidator" do
         end
       end
     end
-    context "when name = :title" do
+    context 'when name = :title' do
       let(:name) { :title }
-      context "when options is correct" do
-        context "(as string)" do
-          let(:options) { {"pattern" => /foo/} }
+      context 'when options is correct' do
+        context '(as string)' do
+          let(:options) { {'pattern' => /foo/} }
           it do
-            expect(subject).to be_a(Proc)
+            is_expected.to be_a(Proc)
             expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:title]).to be_a Proc
           end
         end
-        context "(as symbol)" do
+        context '(as symbol)' do
           let(:options) { {pattern: /foo/} }
           it do
-            expect(subject).to be_a(Proc)
+            is_expected.to be_a(Proc)
             expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:title]).to be_a Proc
           end
         end
       end
-      context "when options is incorrect" do
-        context "(missing pattern)" do
+      context 'when options is incorrect' do
+        context '(missing pattern)' do
           let(:options) { {} }
           it do
             expect(log).to receive(:error).with(Howitzer::WrongOptionError, "Please specify ':pattern' option as Regexp object").once.and_call_original
             expect { subject }.to raise_error(Howitzer::WrongOptionError)
           end
         end
-        context "(string pattern)" do
-          let(:options) { {pattern: "foo"} }
+        context '(string pattern)' do
+          let(:options) { {pattern: 'foo'} }
           it do
             expect(log).to receive(:error).with(Howitzer::WrongOptionError, "Please specify ':pattern' option as Regexp object").once.and_call_original
             expect { subject }.to raise_error(Howitzer::WrongOptionError)
@@ -179,7 +179,7 @@ describe "PageValidator" do
         end
       end
     end
-    context "when other name" do
+    context 'when other name' do
       let(:name) { :unknown }
       let(:options) { {} }
       it do
@@ -189,52 +189,52 @@ describe "PageValidator" do
     end
   end
 
-  describe ".pages" do
+  describe '.pages' do
     subject { Howitzer::Utils::PageValidator.pages }
-    it { expect(subject).to eq([]) }
+    it { is_expected.to eq([]) }
     it do
       subject << Class
-      expect(subject).to eql([Class])
+      is_expected.to eql([Class])
     end
   end
 
-  describe ".opened?" do
+  describe '.opened?' do
     subject { web_page_class.opened? }
-    context "when no one validation is defined" do
+    context 'when no one validation is defined' do
       it do
         expect(log).to receive(:error).with(Howitzer::NoValidationError, "No any page validation was found for 'TestWebPageClass' page").once.and_call_original
         expect { subject }.to raise_error(Howitzer::NoValidationError)
       end
     end
-    context "when all validations are defined" do
+    context 'when all validations are defined' do
       before do
         web_page_class.class_eval do
-          add_locator   :login,  "#id"
+          add_locator   :login, '#id'
           validates :url, pattern: /foo/
           validates :title, pattern: /Foo page/
           validates :element_presence, locator: :login
         end
       end
-      context "when all matches" do
+      context 'when all matches' do
         before do
           allow(web_page_class).to receive(:url){ 'http://test.com/foo' }
           allow(web_page_class).to receive(:title){ 'Foo page' }
           allow(web_page_class).to receive(:first_element).with(:login){ true }
         end
-        it { expect(subject).to be_true }
+        it { is_expected.to be_truthy }
       end
-      context "when first does not match" do
+      context 'when first does not match' do
         before do
           expect(web_page_class).to receive(:url).once{ 'http://test.com/bar' }
           expect(web_page_class).to receive(:title).never
           expect(web_page_class).to receive(:first_element).never
         end
-        it { expect(subject).to be_false }
+        it { is_expected.to be_falsey }
       end
     end
   end
 
-  describe "#matched_pages" do
+  describe '#matched_pages' do
     let!(:web_page1_class) do
       Class.new do
         include Howitzer::Utils::PageValidator
@@ -260,7 +260,6 @@ describe "PageValidator" do
     end
     subject {web_page2_class.matched_pages }
     before { Howitzer::Utils::PageValidator.instance_variable_set(:@pages, [web_page1_class, web_page2_class]) }
-    it { expect(subject).to eq([web_page1_class]) }
+    it { is_expected.to eq([web_page1_class]) }
   end
-
-end
+end