howitzer 1.0.1 → 1.0.2

data/spec/unit/lib/init_spec.rb

@@ -1,14 +1,3 @@
 require 'spec_helper'
-require "#{lib_path}/howitzer/utils/data_generator/gen.rb"
+require 'howitzer/utils/data_generator/gen.rb'
 require 'capybara/dsl'
-
-describe "Helpers" do
-  before do
-    stub_const("Mailgun", double)
-    expect(settings).to receive(:mailgun_api_key){ 'some_api' }
-  end
-  it "should init Mailgun and include modules" do
-    expect(Mailgun).to receive(:init).with('some_api').once
-    require "#{lib_path}/howitzer/init.rb"
-  end
-end

data/spec/unit/lib/mailgun/client_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'howitzer/mailgun/client'
+
+describe Mailgun::Client do
+  let(:mg_obj) { Mailgun::Client.new("Fake-API-Key") }
+  describe ".new" do
+    subject { mg_obj }
+    it { expect { subject }.not_to raise_error }
+  end
+
+  describe "#get" do
+    let(:query_string){ {'skip' => '10', 'limit' => '5'} }
+    subject { mg_obj.get("test.com/bounces", query_string) }
+    context "when simulation of client" do
+      before do
+        expect(RestClient::Resource).to receive(:new).once { Mailgun::UnitClient::new('Fake-API-Key', 'api.mailgun.net', 'v2') }
+      end
+      it do
+        expect(subject.body).to include("total_count")
+        expect(subject.body).to include("items")
+      end
+    end
+    context "when real client" do
+      let(:resource) { double }
+      before do
+        allow(resource).to receive('[]'){ resource }
+        allow(resource).to receive(:get).and_raise(StandardError, '401 Unauthorized: Forbidden')
+        allow(RestClient::Resource).to receive(:new) { resource }
+      end
+      it do
+        expect(log).to receive(:error).with(Howitzer::CommunicationError, '401 Unauthorized: Forbidden').once.and_call_original
+        expect { subject }.to raise_error(Howitzer::CommunicationError)
+      end
+    end
+  end
+end

data/spec/unit/lib/mailgun/connector_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'howitzer/mailgun/connector'
+
+describe Mailgun::Connector do
+  let(:connector) { Mailgun::Connector.instance }
+  let(:domain_name) { 'test@domain.com' }
+  describe "#client" do
+    subject { connector.client }
+    context "when api_key is default" do
+      context "when client is not initialized" do
+        it { expect(subject).to be_an_instance_of Mailgun::Client }
+      end
+      context "when client is already initialized" do
+        it do
+          object_id = connector.client.object_id
+          expect(subject.object_id).to eq(object_id)
+        end
+      end
+    end
+    context "when api_key is custom" do
+      let(:key) { "some api key" }
+      subject { connector.client(key) }
+      it { expect(subject).to be_an_instance_of Mailgun::Client }
+    end
+    context "when api_key is nil" do
+      let(:key) { nil }
+      subject { connector.client(key) }
+      it do
+        expect(log).to receive(:error).with(Howitzer::InvalidApiKeyError, "Api key can not be blank").once.and_call_original
+        expect { subject }.to raise_error(Howitzer::InvalidApiKeyError)
+      end
+    end
+    context "when api_key is blank string" do
+      let(:key) { "" }
+      subject { connector.client(key) }
+      it do
+        expect(log).to receive(:error).with(Howitzer::InvalidApiKeyError, "Api key can not be blank").once.and_call_original
+        expect { subject }.to raise_error(Howitzer::InvalidApiKeyError)
+      end
+    end
+  end
+  describe '#domain' do
+    subject { connector.domain }
+    context "when domain is not set" do
+      before { connector.instance_variable_set(:@domain, nil)}
+      it do
+        expect(connector).to receive(:change_domain).once{ domain_name }
+        expect(subject).to eq(domain_name)
+      end
+    end
+    context "when domain is already set" do
+      before do
+        expect(connector).to receive(:change_domain).never
+        connector.instance_variable_set(:@domain, domain_name)
+      end
+      it { expect(subject).to eql(domain_name) }
+    end
+  end
+
+  describe '#change_domain' do
+    context "when default" do
+      before { connector.change_domain }
+      it { expect(connector.instance_variable_get(:@domain)).to eq(settings.mailgun_domain)}
+    end
+    context "when custom" do
+      before { connector.change_domain(domain_name) }
+      it { expect(connector.instance_variable_get(:@domain)).to eq(domain_name) }
+    end
+  end
+end

data/spec/unit/lib/mailgun/response_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'howitzer/mailgun/client'
+require 'howitzer/exceptions'
+
+describe Mailgun::Response do
+  let(:body) { {foo: 'bar'}.to_json }
+  let(:response) { double(:response, body: body, code: 201)}
+  describe "#body" do
+    subject { Mailgun::Response.new(response).body }
+    it { expect(subject).to eq("{\"foo\":\"bar\"}")}
+  end
+  describe "#code" do
+    subject { Mailgun::Response.new(response).code }
+    it { expect(subject).to eq(201)}
+  end
+  describe "#to_h" do
+    subject { Mailgun::Response.new(response).to_h }
+    context "when possible parse body" do
+      it { expect(subject).to eq({"foo"=>"bar"})}
+    end
+    context "when impossible parse body" do
+      let(:body) { '123' }
+      it do
+        expect(log).to receive(:error).with(Howitzer::ParseError, "757: unexpected token at '123'").once.and_call_original
+        expect { subject }.to raise_error(Howitzer::ParseError)
+      end
+    end
+  end
+end

data/spec/unit/lib/utils/data_generator/data_storage_spec.rb

@@ -1,8 +1,9 @@
 require 'spec_helper'
-require "#{lib_path}/howitzer/utils/data_generator/data_storage"
+require 'howitzer/utils/data_generator/data_storage'
 
 describe "DataGenerator" do
   describe "DataStorage" do
+    before { DataGenerator::DataStorage.data.clear }
     describe ".store" do
       subject { DataGenerator::DataStorage.store(ns, 7, :halt) }
       context "when namespace specified" do
@@ -11,8 +12,8 @@ describe "DataGenerator" do
           expect(subject).to eql(:halt)
         end
         it "should store namespace value" do
-          adata = DataGenerator::DataStorage.instance_variable_get(:@data)
-          expect(adata[:user]).to eql({7 => :halt})
+          subject
+          expect(DataGenerator::DataStorage.data[:user]).to eql({7 => :halt})
         end
       end
       context "when namespace empty" do
@@ -22,7 +23,7 @@ describe "DataGenerator" do
     end
     describe ".extract" do
       subject { DataGenerator::DataStorage.extract(ns, key) }
-      before { DataGenerator::DataStorage.instance_variable_set(:@data, {user: {7 => :exit}}) }
+      before { DataGenerator::DataStorage.data[:user] = {7 => :exit} }
       describe "when namespace specified" do
         let(:ns) { :user }
         context "and namespace key found" do
@@ -51,12 +52,29 @@ describe "DataGenerator" do
     end
     describe ".clear_ns" do
       subject { DataGenerator::DataStorage.clear_ns(:user) }
-      before { DataGenerator::DataStorage.instance_variable_set(:@data, {user: {7 => :exit}}) }
+      before { DataGenerator::DataStorage.data[:user]= {7 => :exit}}
       it "should return empty hash" do
         subject
         adata = DataGenerator::DataStorage.instance_variable_get(:@data)
         expect(adata[:user]).to eql({})
       end
     end
+    describe ".clear_all_ns" do
+      before do
+        DataGenerator::DataStorage.store('sauce', :status, false)
+        DataGenerator::DataStorage.store(:foo, "foo", "some value1")
+        DataGenerator::DataStorage.store(:bar, "bar", "some value2")
+        DataGenerator::DataStorage.store(:baz, "baz", "some value3")
+      end
+      context "when default argument" do
+        before { DataGenerator::DataStorage.clear_all_ns }
+        it { expect(DataGenerator::DataStorage.data).to eq({"sauce"=>{:status=>false}, :foo=>{}, :bar=>{}, :baz=>{}}) }
+      end
+      context "when custom argument" do
+        let(:exception_list) { [:foo, :bar] }
+        before { DataGenerator::DataStorage.clear_all_ns(exception_list) }
+        it { expect(DataGenerator::DataStorage.data).to eq({"sauce"=>{}, :foo=>{"foo"=>"some value1"}, :bar=>{"bar"=>"some value2"}, :baz=>{}}) }
+      end
+    end
   end
 end

data/spec/unit/lib/utils/data_generator/gen_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require "#{lib_path}/howitzer/utils/data_generator/gen"
+require 'howitzer/utils/data_generator/gen'
 
 describe "DataGenerator" do
   describe "Gen" do
@@ -7,7 +7,7 @@ describe "DataGenerator" do
       subject { DataGenerator::Gen.user(params) }
       before do
         allow(settings).to receive(:def_test_pass) { 'test_pass' }
-        allow(settings).to receive(:mail_pop3_domain) { 'mail.com' }
+        allow(settings).to receive(:mailgun_domain) { 'mail.com' }
         allow(DataGenerator::Gen).to receive(:serial) { '012345678abcde' }
       end
       context "when params specified" do
@@ -23,7 +23,6 @@ describe "DataGenerator" do
         it { expect(subject.password).to eql 'pa$$w0rd' }
         it { expect(subject.first_name).to eql 'FirstName012345678abcde' }
         it { expect(subject.last_name).to eql 'LastName012345678abcde' }
-        it { expect(subject.mailbox).to eql 'member@test.com' }
       end
       context "with empty params" do
         let(:params) { {} }
@@ -38,7 +37,6 @@ describe "DataGenerator" do
         it { expect(subject.password).to eql 'test_pass' }
         it { expect(subject.first_name).to eql 'FirstName012345678abcde' }
         it { expect(subject.last_name).to eql 'LastName012345678abcde' }
-        it { expect(subject.mailbox).to be_nil }
       end
     end
     describe ".given_user_by_number" do
@@ -69,20 +67,6 @@ describe "DataGenerator" do
         it { expect(subject).to_not eql ser }
       end
     end
-    describe ".delete_all_mailboxes" do
-      subject { DataGenerator::Gen.delete_all_mailboxes }
-      let(:mbox1) { double }
-      let(:mbox2) { double }
-      before do
-        stub_const("DataGenerator::DataStorage", double)
-        expect(DataGenerator::DataStorage).to receive(:extract).with('user') { { 1 => mbox1, 2 => mbox2 } }
-      end
-      it do
-        expect(mbox1).to receive(:delete_mailbox).once
-        expect(mbox2).to receive(:delete_mailbox).once
-        subject
-      end
-    end
     describe "User" do
       describe "#initialize" do
         subject { DataGenerator::Gen::User.new(params) }
@@ -100,51 +84,6 @@ describe "DataGenerator" do
         it { expect(subject.first_name).to eql 'Alexey' }
         it { expect(subject.last_name).to eql 'Petrenko' }
         it { expect(subject.full_name).to eql 'Alexey Petrenko' }
-        it { expect(subject.mailbox).to eql 'member@test.com' }
-      end
-      describe "#create_mailbox" do
-        subject { nu_user.create_mailbox }
-        let(:nu_user) { DataGenerator::Gen::User.new({ email: 'alex.petrenko@mail.com', mailbox: 'member@test.com' }) }
-        before { stub_const('MailClient', double) }
-        context "should return User object" do
-          before do
-            allow(settings).to receive(:mail_pop3_domain) { 'mail.com' }
-            expect(MailClient).to receive(:create_mailbox).with('alex.petrenko').once { 'petrenko@test.com' }
-          end
-          it { expect(subject).to be_an_instance_of DataGenerator::Gen::User }
-        end
-        context "when mail_pop3_domain settings are equal to @domain" do
-          before do
-            allow(settings).to receive(:mail_pop3_domain) { 'mail.com' }
-            expect(MailClient).to receive(:create_mailbox).with('alex.petrenko').once { 'petrenko@test.com' }
-          end
-          it do
-            subject
-            expect(nu_user.mailbox).to eql 'petrenko@test.com'
-          end
-        end
-        context "when mail_pop3_domain settings are not equal to @domain" do
-          before { allow(settings).to receive(:mail_pop3_domain) { 'post.com' } }
-          it do
-            subject
-            expect(nu_user.mailbox).to eql 'member@test.com'
-          end
-        end
-      end
-      describe "#delete_mailbox" do
-        subject { nu_user.delete_mailbox }
-        let(:nu_user) { DataGenerator::Gen::User.new({ mailbox: mbox }) }
-        before { stub_const('MailClient', double) }
-        context "when mailbox spcified" do
-          before { expect(MailClient).to receive(:delete_mailbox).with(mbox).once { 'mailbox deleted' } }
-          let(:mbox) { 'member@test.com' }
-          it { expect(subject).to eql 'mailbox deleted' }
-        end
-        context "when mailbox not spcified" do
-          before { expect(MailClient).to_not receive(:delete_mailbox).with(mbox) }
-          let(:mbox) { nil }
-          it { expect(subject).to be_nil }
-        end
       end
     end
   end

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

@@ -1,15 +1,18 @@
 require 'spec_helper'
-require "#{lib_path}/howitzer/utils/locator_store"
+require 'howitzer/utils/locator_store'
 
 describe "Locator store" do
   let(:bad_name) { 'name' }
-  let(:error) { LocatorStore::LocatorNotDefinedError }
+  let(:error) { Howitzer::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) }
+        it do
+          expect(log).to receive(:error).with(error, bad_name).once.and_call_original
+          expect { subject }.to raise_error(error)
+        end
       end
       context "when CSS locator given" do
         before { web_page.add_locator :base_locator, 'base_locator' }
@@ -90,17 +93,49 @@ describe "Locator store" do
       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") }
+        it { expect{ subject }.to raise_error(Howitzer::LocatorNotDefinedError, "unknown_locator") }
+      end
+    end
+    describe "#{prefix}first_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.first_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(:first).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(:first).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.first_element(:test_link_locator) }
+          it do
+            expect(web_page.is_a?(Class) ? web_page : web_page.class).to receive(:first).with(:link, 'foo')
+            subject
+          end
+        end
+      end
+      context "when not existing locator name" do
+        subject { web_page.first_element(:unknown_locator) }
+        it { expect{ subject }.to raise_error(Howitzer::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}')]"}} }

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

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require "#{lib_path}/howitzer/utils/log"
+require 'howitzer/utils/log'
 include LoggerHelper
 
 describe "Logger" do

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

@@ -1,5 +1,6 @@
 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
@@ -8,29 +9,57 @@ describe Howitzer::Utils::PageValidator do
 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 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 all validation are 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
+      before do
         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
+      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 { 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" }
@@ -39,25 +68,31 @@ describe "PageValidator" 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" }
@@ -70,7 +105,7 @@ describe "PageValidator" 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
@@ -95,11 +130,17 @@ describe "PageValidator" do
       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
@@ -110,33 +151,116 @@ describe "PageValidator" 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