page_validator_spec.rb in howitzer-1.1.0

- old
+ new

@@ -1,242 +1,242 @@
 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
       include Howitzer::Utils::PageValidator
       def self.name
         'TestWebPageClass'
       end
     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
       it { expect{subject}.to_not raise_error }
     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)
           end
         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)
           end
         end
       end
     end
-    context "when other name" do
+    context 'when other name' do
       let(:name) { :unknown }
       let(:options) { {} }
       it do
         expect(log).to receive(:error).with(Howitzer::UnknownValidationError, "unknown 'unknown' validation name").once.and_call_original
         expect { subject }.to raise_error(Howitzer::UnknownValidationError)
       end
     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
         def self.name
           'TestWebPage1Class'
@@ -258,9 +258,8 @@
         end
       end
     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
\ No newline at end of file