page_validator_spec.rb in howitzer-1.0.2

- old
+ new

@@ -1,65 +1,100 @@
 require 'spec_helper'
-require "#{lib_path}/howitzer/utils/page_validator"
+require "howitzer/utils/page_validator"
+require "howitzer/utils/locator_store"
 
 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 }
+  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
+    subject { web_page.check_validations_are_defined! }
     context "when no validation specified" do
-      it { expect{subject}.to raise_error(Howitzer::Utils::PageValidator::NoValidationError, "No any page validation was found") }
+      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 validation are specified" do
+    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{subject}.to_not raise_error
+      end
+    end
+    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
+      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
+      before do
         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
+      it { expect{subject}.to_not raise_error }
     end
   end
 
   describe ".validates" do
-    subject { web_page.class.validates(name, options)}
+    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/} }
             it do
               expect(subject).to be_a(Proc)
-              expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:url]).to eql(subject)
+              expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:url]).to be_a Proc
             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)
+              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
             let(:options) { {} }
-            it { expect{subject}.to raise_error(Howitzer::Utils::PageValidator::WrongOptionError, "Please specify ':pattern' option as Regexp object") }
+            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"} }
-            it { expect{subject}.to raise_error(Howitzer::Utils::PageValidator::WrongOptionError, "Please specify ':pattern' option as Regexp object") }
+            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" }
             it { expect{subject}.to raise_error(TypeError, "Expected options to be Hash, actual is 'String'") }
           end
@@ -68,11 +103,11 @@
       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)
+          expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:url]).to be_a Proc
         end
       end
     end
     context "when name = :element_presence" do
       let(:name) { :element_presence }
@@ -93,50 +128,139 @@
         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") }
+          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: ""} }
-          it { expect{subject}.to raise_error(Howitzer::Utils::PageValidator::WrongOptionError, "Please specify ':locator' option as one of page locator names") }
+          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
       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)
+            expect(Howitzer::Utils::PageValidator.validations[web_page.class.name][:title]).to be_a Proc
           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)
+            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
           let(:options) { {} }
-          it { expect{subject}.to raise_error(Howitzer::Utils::PageValidator::WrongOptionError, "Please specify ':pattern' option as Regexp object") }
+          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"} }
-          it { expect{subject}.to raise_error(Howitzer::Utils::PageValidator::WrongOptionError, "Please specify ':pattern' option as Regexp object") }
+          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
       let(:name) { :unknown }
       let(:options) { {} }
-      it { expect{subject}.to raise_error(Howitzer::Utils::PageValidator::UnknownValidationName, "unknown 'unknown' validation name") }
+      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
+    subject { Howitzer::Utils::PageValidator.pages }
+    it { expect(subject).to eq([]) }
+    it do
+      subject << Class
+      expect(subject).to eql([Class])
+    end
+  end
+
+  describe ".opened?" do
+    subject { web_page_class.opened? }
+    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
+      before do
+        web_page_class.class_eval do
+          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
+        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 }
+      end
+      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 }
+      end
+    end
+  end
+
+  describe "#matched_pages" do
+    let!(:web_page1_class) do
+      Class.new do
+        include Howitzer::Utils::PageValidator
+        def self.name
+          'TestWebPage1Class'
+        end
+        def self.opened?
+          true
+        end
+      end
+    end
+
+    let!(:web_page2_class) do
+      Class.new do
+        include Howitzer::Utils::PageValidator
+        def self.name
+          'TestWebPage2Class'
+        end
+        def self.opened?
+          false
+        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]) }
   end
 
 end