howitzer 2.0.0 → 2.0.1

data/spec/unit/generators/cucumber_generator_spec.rb

@@ -28,6 +28,7 @@ RSpec.describe 'Generators' do
         },
         { name: '/features/support', is_directory: true },
         { name: '/features/support/env.rb', is_directory: false, size: template_file_size('cucumber', 'env.rb') },
+        { name: '/features/support/hooks.rb', is_directory: false, size: template_file_size('cucumber', 'hooks.rb') },
         {
           name: '/features/support/transformers.rb',
           is_directory: false,
@@ -43,6 +44,7 @@ RSpec.describe 'Generators' do
         "  * Cucumber integration to the framework ...
       Added 'features/step_definitions/common_steps.rb' file
       Added 'features/support/env.rb' file
+      Added 'features/support/hooks.rb' file
       Added 'features/support/transformers.rb' file
       Added 'features/example.feature' file
       Added 'tasks/cucumber.rake' file\n"

data/spec/unit/generators/root_generator_spec.rb

@@ -16,7 +16,7 @@ RSpec.describe 'Generators' do
       [
         { name: '/.gitignore', is_directory: false, size: 196 },
         { name: '/.rubocop.yml', is_directory: false, size: 584 },
-        { name: '/Gemfile', is_directory: false, size: 605 },
+        { name: '/Gemfile', is_directory: false, size: 625 },
         { name: '/Rakefile', is_directory: false, size: template_file_size('root', 'Rakefile') }
       ]
     end

data/spec/unit/lib/capybara_helpers_spec.rb

@@ -681,8 +681,8 @@ RSpec.describe Howitzer::CapybaraHelpers do
   describe '.load_driver_gem!' do
     subject { load_driver_gem!(:webkit, 'capybara-webkit', 'capybara-webkit') }
     context 'when possible to require' do
-      before { allow(self).to receive(:require).with(:webkit) { true } }
-      it { expect { subject }.not_to raise_error(LoadError) }
+      before { allow(self).to receive(:require).with('capybara-webkit') { true } }
+      it { expect { subject }.not_to raise_error }
     end
     context 'when impossible to require' do
       it do

data/spec/unit/lib/email_spec.rb

@@ -37,22 +37,43 @@ RSpec.describe Howitzer::Email do
   describe '.subject' do
     it do
       described_class.send(:subject, message_subject)
-      expect(described_class.instance_variable_get(:@subject)).to eql message_subject
+      expect(described_class.send(:subject_value)).to eql message_subject
+      expect(described_class.private_methods(true)).to include(:subject_value)
     end
     it 'should be protected' do
       expect { described_class.subject(message_subject) }.to raise_error(NoMethodError)
     end
   end
 
+  describe '.wait_time' do
+    subject { Class.new(described_class) }
+    it 'should be protected' do
+      expect { subject.wait_time(10) }.to raise_error(NoMethodError)
+    end
+
+    context 'when specified' do
+      before { subject.send(:wait_time, 10) }
+      it do
+        expect(subject.send(:wait_time_value)).to eql 10
+        expect(subject.private_methods(true)).to include(:wait_time_value)
+      end
+    end
+
+    context 'when missing' do
+      it do
+        expect(subject.send(:wait_time_value)).to eql 60
+      end
+    end
+  end
+
   describe '.find_by_recipient' do
     let(:recipient) { 'test@user.com' }
 
     context 'simple subject without parameters' do
-      subject { described_class.find_by_recipient(recipient) }
       before { described_class.class_eval { subject 'Some title' } }
       it do
-        expect(described_class.adapter).to receive(:find).with(recipient, 'Some title').once
-        subject
+        expect(described_class.adapter).to receive(:find).with(recipient, 'Some title', wait: 60).once
+        described_class.find_by_recipient(recipient)
       end
     end
 
@@ -60,7 +81,7 @@ RSpec.describe Howitzer::Email do
       subject { described_class.find_by_recipient(recipient, name: 'Vasya') }
       before { described_class.class_eval { subject 'Some title from :name' } }
       it do
-        expect(described_class.adapter).to receive(:find).with(recipient, 'Some title from Vasya').once
+        expect(described_class.adapter).to receive(:find).with(recipient, 'Some title from Vasya', wait: 60).once
         subject
       end
     end
@@ -69,12 +90,22 @@ RSpec.describe Howitzer::Email do
       subject { described_class.find_by_recipient(recipient, foo: 1, bar: 2) }
       before { described_class.class_eval { subject 'Some title with :foo and :bar' } }
       it do
-        expect(described_class.adapter).to receive(:find).with(recipient, 'Some title with 1 and 2').once
+        expect(described_class.adapter).to receive(:find).with(recipient, 'Some title with 1 and 2', wait: 60).once
         subject
       end
     end
 
     context 'missing subject' do
+      subject { described_class.find_by_recipient(recipient) }
+      before do
+        described_class.instance_eval { undef :subject_value }
+      end
+      it do
+        expect { subject }.to raise_error(Howitzer::NoEmailSubjectError)
+      end
+    end
+
+    context 'nil subject' do
       subject { described_class.find_by_recipient(recipient) }
       before { described_class.class_eval { subject nil } }
       it do

data/spec/unit/lib/{howitzer.rb → howitzer_spec.rb}

@@ -28,4 +28,13 @@ RSpec.describe 'Howitzer' do
       it { expect(Howitzer.app_uri.site).to eq('http://redmine.strongqa.com') }
     end
   end
+  describe '.mailgun_idle_timeout' do
+    subject { Howitzer.mailgun_idle_timeout }
+    before do
+      expect_any_instance_of(Object).to receive(:puts).with(
+        "WARNING! 'mailgun_idle_timeout' setting is deprecated. Please replace with 'mail_wait_time' setting."
+      )
+    end
+    it { is_expected.to eq(0.5) }
+  end
 end

data/spec/unit/lib/mail_adapters/abstract_spec.rb

@@ -10,7 +10,7 @@ RSpec.describe Howitzer::MailAdapters::Abstract do
   let(:email_object) { Howitzer::Email.adapter.new(message) }
 
   describe '.find' do
-    subject { described_class.find(recipient, message_subject) }
+    subject { described_class.find(recipient, message_subject, _wait: 10) }
     it { expect { subject }.to raise_error(NotImplementedError) }
   end
 

data/spec/unit/lib/mail_adapters/mailgun_spec.rb

@@ -29,7 +29,7 @@ RSpec.describe 'Mailgun Email Adapter' do
   describe '.find' do
     let(:mailgun_message) { double(to_h: message) }
     let(:events) { double(to_h: { 'items' => [event] }) }
-    subject { Howitzer::MailAdapters::Mailgun.find(recipient, message_subject) }
+    subject { Howitzer::MailAdapters::Mailgun.find(recipient, message_subject, wait: 0.01) }
 
     context 'when message is found' do
       let(:event) do
@@ -50,10 +50,10 @@ RSpec.describe 'Mailgun Email Adapter' do
         allow(Howitzer::MailgunApi::Connector.instance.client).to receive(:get).with(
           'mailgun@test.domain/events',
           params: { event: 'stored' }
-        ).ordered.once { events }
+        ) { events }
         allow(Howitzer::MailgunApi::Connector.instance.client).to receive(:get_url).with(
           'https://si.api.mailgun.net/v3/domains/mg.strongqa.com/messages/1234567890'
-        ).ordered.once { mailgun_message }
+        ) { mailgun_message }
       end
       it do
         expect(Howitzer::Email.adapter).to receive(:new).with(message).once
@@ -80,7 +80,7 @@ RSpec.describe 'Mailgun Email Adapter' do
         allow(Howitzer::MailgunApi::Connector.instance.client).to receive(:get).with(
           'mailgun@test.domain/events',
           params: { event: 'stored' }
-        ).at_least(:twice).ordered { events }
+        ) { events }
       end
       it do
         expect { subject }.to raise_error(

data/spec/unit/lib/web/base_section_spec.rb

@@ -9,7 +9,9 @@ RSpec.describe Howitzer::Web::BaseSection do
 
     let(:klass) { Class.new(described_class) }
     let(:klass_object) { klass.new(parent, capybara_context) }
-    before { allow(klass_object).to receive(:capybara_context) { kontext } }
+    it 'returns correct capybara context' do
+      expect(klass_object.capybara_context).to eq(capybara_context)
+    end
 
     include_examples :element_dsl
   end

data/spec/unit/lib/web/element_dsl_spec.rb

@@ -5,13 +5,18 @@ RSpec.describe Howitzer::Web::ElementDsl do
   let(:klass) do
     Class.new do
       include Howitzer::Web::ElementDsl
-      def capybara_context
-        Capybara.current_session
+      def capybara_scopes
+        @_scopes ||= [Capybara.current_session]
       end
     end
   end
   let(:klass_object) { klass.new }
 
+  it 'returns correct capybara context' do
+    allow(Capybara).to receive(:current_session) { 'session' }
+    expect(klass_object.capybara_context).to eq('session')
+  end
+
   include_examples :element_dsl
   include_examples :capybara_context_holder
 end

data/spec/unit/lib/web/page_dsl_spec.rb

@@ -42,6 +42,28 @@ RSpec.describe Howitzer::Web::PageDsl::PageScope do
       it { expect(subject.class).to eq(RSpec::Matchers::BuiltIn::Has) }
     end
 
+    context 'when out' do
+      let(:outer_context) do
+        Class.new do
+          def initialize(klass)
+            @klass = klass
+            @a = 5
+          end
+
+          def scope
+            @klass.new(nil) { 1 }
+          end
+
+          def secret
+            '***'
+          end
+        end
+      end
+      let(:scope) { outer_context.new(described_class).scope }
+      it { expect(scope.out(:@a)).to eq(5) }
+      it { expect(scope.out(:secret)).to eq('***') }
+    end
+
     context 'when starts other prefix' do
       let(:scope) { described_class.new(page) { 1 } }
       subject { scope.foo(1, 2, 3) }

data/spec/unit/lib/web/page_spec.rb

@@ -14,7 +14,21 @@ RSpec.describe Howitzer::Web::Page do
         let(:url_value) { 'http://example.com/users/1' }
         subject { described_class.open(id: 1) }
         it do
-          expect(described_class).to receive(:expanded_url).with(id: 1) { url_value }.once.ordered
+          expect(described_class).to receive(:expanded_url).with({ id: 1 }, nil) { url_value }.once.ordered
+          expect(Howitzer::Log).to receive(:info)
+            .with("Open #{described_class} page by '#{url_value}' url").once.ordered
+          expect(described_class).to receive(:retryable).ordered.once.and_call_original
+          expect(session).to receive(:visit).with(url_value).once.ordered
+          expect(described_class).to receive(:given).once.ordered { true }
+          expect(subject).to eq(true)
+        end
+      end
+      context 'when custom processor specified' do
+        let(:custom_processor) { double }
+        let(:url_value) { 'http://example.com/users/1' }
+        subject { described_class.open(id: 1, url_processor: custom_processor) }
+        it do
+          expect(described_class).to receive(:expanded_url).with({ id: 1 }, custom_processor) { url_value }.once.ordered
           expect(Howitzer::Log).to receive(:info)
             .with("Open #{described_class} page by '#{url_value}' url").once.ordered
           expect(described_class).to receive(:retryable).ordered.once.and_call_original
@@ -27,7 +41,7 @@ RSpec.describe Howitzer::Web::Page do
         let(:url_value) { 'http://example.com/users' }
         subject { described_class.open }
         it do
-          expect(described_class).to receive(:expanded_url).with({}) { url_value }.once.ordered
+          expect(described_class).to receive(:expanded_url).with({}, nil) { url_value }.once.ordered
           expect(Howitzer::Log).to receive(:info)
             .with("Open #{described_class} page by '#{url_value}' url").once.ordered
           expect(described_class).to receive(:retryable).ordered.once.and_call_original
@@ -41,7 +55,7 @@ RSpec.describe Howitzer::Web::Page do
       let(:url_value) { 'http://example.com/users' }
       subject { described_class.open(validate: false) }
       it do
-        expect(described_class).to receive(:expanded_url).with({}) { url_value }.once.ordered
+        expect(described_class).to receive(:expanded_url).with({}, nil) { url_value }.once.ordered
         expect(Howitzer::Log).to receive(:info).with("Open #{described_class} page by '#{url_value}' url").once.ordered
         expect(described_class).to receive(:retryable).ordered.once.and_call_original
         expect(session).to receive(:visit).with(url_value).once.ordered
@@ -53,7 +67,7 @@ RSpec.describe Howitzer::Web::Page do
       let(:url_value) { 'http://example.com/users/1' }
       subject { described_class.open(validate: true, id: 1) }
       it do
-        expect(described_class).to receive(:expanded_url).with(id: 1) { url_value }.once.ordered
+        expect(described_class).to receive(:expanded_url).with({ id: 1 }, nil) { url_value }.once.ordered
         expect(Howitzer::Log).to receive(:info).with("Open #{described_class} page by '#{url_value}' url").once.ordered
         expect(described_class).to receive(:retryable).ordered.once.and_call_original
         expect(session).to receive(:visit).with(url_value).once.ordered
@@ -162,41 +176,72 @@ RSpec.describe Howitzer::Web::Page do
     let!(:child_class3) do
       Class.new(described_class)
     end
-    it { expect(described_class.send(:app_host)).to eq('http://login:pass@my.website.com') }
-    it { expect(base_class.send(:app_host)).to eq('https://base.com') }
-    it { expect(child_class1.send(:app_host)).to eq('https://child.com') }
-    it { expect(child_class2.send(:app_host)).to eq('https://base.com') }
-    it { expect(child_class3.send(:app_host)).to eq('http://login:pass@my.website.com') }
+    it { expect(described_class.send(:site_value)).to eq('http://login:pass@my.website.com') }
+    it { expect(base_class.send(:site_value)).to eq('https://base.com') }
+    it { expect(child_class1.send(:site_value)).to eq('https://child.com') }
+    it { expect(child_class2.send(:site_value)).to eq('https://base.com') }
+    it { expect(child_class3.send(:site_value)).to eq('http://login:pass@my.website.com') }
     it 'should be protected' do
       expect { described_class.site('http://example.com') }.to raise_error(NoMethodError)
     end
   end
 
   describe '.expanded_url' do
-    context 'when params present' do
-      subject { test_page.expanded_url(id: 1) }
-      context 'when page url specified' do
-        context 'when BlankPage' do
-          let(:test_page) { Howitzer::Web::BlankPage }
-          it { is_expected.to eq('about:blank') }
-        end
-        context 'when other page' do
-          let(:test_page) do
-            Class.new(described_class) do
-              site 'http://example.com'
-              path '/users{/id}'
+    context 'when default url processor' do
+      context 'when params present' do
+        subject { test_page.expanded_url(id: 1) }
+        context 'when page url specified' do
+          context 'when BlankPage' do
+            let(:test_page) { Howitzer::Web::BlankPage }
+            it { is_expected.to eq('about:blank') }
+          end
+          context 'when other page' do
+            let(:test_page) do
+              Class.new(described_class) do
+                site 'http://example.com'
+                path '/users{/id}'
+              end
+            end
+            it { is_expected.to eq('http://example.com/users/1') }
+          end
+          context 'when root not specified' do
+            let(:test_page) do
+              Class.new(described_class) do
+                path '/users{/id}'
+              end
             end
+            it { is_expected.to eq('http://login:pass@my.website.com/users/1') }
+          end
+        end
+      end
+      context 'when custom url processor' do
+        let(:test_page) do
+          Class.new(described_class) do
+            site 'http://example.com'
+            path '/users{/id}'
           end
-          it { is_expected.to eq('http://example.com/users/1') }
         end
-        context 'when root not specified' do
-          let(:test_page) do
-            Class.new(described_class) do
-              path '/users{/id}'
+        let(:custom_processor_class) do
+          Class.new do
+            def self.restore(_name, value)
+              value.tr('-', ' ')
+            end
+
+            def self.match(_name)
+              '.*'
+            end
+
+            def self.validate(_name, value)
+              !(value =~ /^[\w ]+$/).nil?
+            end
+
+            def self.transform(_name, value)
+              value.tr(' ', '+')
             end
           end
-          it { is_expected.to eq('http://login:pass@my.website.com/users/1') }
         end
+        subject { test_page.expanded_url({ id: 'hello world' }, custom_processor_class) }
+        it { is_expected.to eq('http://example.com/users/hello+world') }
       end
       context 'when page url missing' do
         subject { described_class.expanded_url }
@@ -225,11 +270,16 @@ RSpec.describe Howitzer::Web::Page do
     before { subject }
     context 'when value is number' do
       let(:value) { 1 }
-      it { expect(described_class.instance_variable_get(:@path_template)).to eq('1') }
+      it do
+        expect(described_class.send(:path_value)).to eql '1'
+        expect(described_class.private_methods(true)).to include(:path_value)
+      end
     end
     context 'when value is string' do
       let(:value) { '/users' }
-      it { expect(described_class.instance_variable_get(:@path_template)).to eq('/users') }
+      it do
+        expect(described_class.send(:path_value)).to eql '/users'
+      end
     end
   end
 
@@ -257,21 +307,6 @@ RSpec.describe Howitzer::Web::Page do
 
   describe 'inherited callback' do
     let(:page_class) { Class.new(described_class) }
-    context 'when abstract class without validations' do
-      let!(:page_class) do
-        Howitzer::Web::PageValidator.instance_variable_set(:@pages, [])
-        Class.new(described_class)
-      end
-      it { expect(Howitzer::Web::PageValidator.pages).to eq([]) }
-    end
-    context 'when class has validations' do
-      let!(:page_class) do
-        allow(described_class).to receive(:validations) { { title: /some text/ } }
-        Howitzer::Web::PageValidator.instance_variable_set(:@pages, [])
-        Class.new(described_class)
-      end
-      it { expect(Howitzer::Web::PageValidator.pages).to eq([page_class]) }
-    end
     it 'can not be instantiated with new' do
       expect { page_class.new }.to raise_error(NoMethodError, "private method `new' called for #{page_class}")
     end

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

@@ -58,7 +58,7 @@ RSpec.describe Howitzer::Web::PageValidator do
 
   describe '.validate' do
     before do
-      described_class.validations[web_page.class.name] = nil
+      described_class.validations[web_page.class] = nil
     end
     let(:additional_value) { nil }
     subject { web_page.class.validate(name, *[value, additional_value].compact) }
@@ -69,14 +69,14 @@ RSpec.describe Howitzer::Web::PageValidator do
           let(:value) { /foo/ }
           it do
             is_expected.to be_a(Proc)
-            expect(described_class.validations[web_page.class.name][:url]).to be_a Proc
+            expect(described_class.validations[web_page.class][:url]).to be_a Proc
           end
         end
         context '(as symbol)' do
           let(:value) { /foo/ }
           it do
             is_expected.to be_a(Proc)
-            expect(described_class.validations[web_page.class.name][:url]).to be_a Proc
+            expect(described_class.validations[web_page.class][:url]).to be_a Proc
           end
         end
       end
@@ -85,7 +85,7 @@ RSpec.describe Howitzer::Web::PageValidator do
         let(:value) { /foo/ }
         it do
           is_expected.to be_a(Proc)
-          expect(described_class.validations[web_page.class.name][:url]).to be_a Proc
+          expect(described_class.validations[web_page.class][:url]).to be_a Proc
         end
       end
     end
@@ -96,14 +96,14 @@ RSpec.describe Howitzer::Web::PageValidator do
         let(:additional_value) { 'some string' }
         it do
           is_expected.to be_a(Proc)
-          expect(described_class.validations[web_page.class.name][:element_presence]).to eql(subject)
+          expect(described_class.validations[web_page.class][:element_presence]).to eql(subject)
         end
       end
       context '(as symbol)' do
         let(:value) { :test_locator }
         it do
           is_expected.to be_a(Proc)
-          expect(described_class.validations[web_page.class.name][:element_presence]).to eql(subject)
+          expect(described_class.validations[web_page.class][:element_presence]).to eql(subject)
         end
       end
     end
@@ -113,14 +113,14 @@ RSpec.describe Howitzer::Web::PageValidator do
         let(:value) { /foo/ }
         it do
           is_expected.to be_a(Proc)
-          expect(described_class.validations[web_page.class.name][:title]).to be_a Proc
+          expect(described_class.validations[web_page.class][:title]).to be_a Proc
         end
       end
       context '(as symbol)' do
         let(:value) { /foo/ }
         it do
           is_expected.to be_a(Proc)
-          expect(described_class.validations[web_page.class.name][:title]).to be_a Proc
+          expect(described_class.validations[web_page.class][:title]).to be_a Proc
         end
       end
     end
@@ -133,18 +133,9 @@ RSpec.describe Howitzer::Web::PageValidator do
     end
   end
 
-  describe '.pages' do
-    subject { described_class.pages }
-    it do
-      expect(subject).not_to include(Symbol)
-      subject << Symbol
-      expect(subject).to include(Symbol)
-    end
-  end
-
   describe '.opened?' do
-    subject { web_page_class.opened? }
     context 'when no one validation is defined' do
+      subject { web_page_class.opened? }
       it do
         expect { subject }.to raise_error(
           Howitzer::NoValidationError,
@@ -153,30 +144,91 @@ RSpec.describe Howitzer::Web::PageValidator do
       end
     end
     context 'when all validations are defined' do
-      before do
-        web_page_class.class_eval do
-          include Singleton
-          element :login, '#id'
-          validate :url, /foo/
-          validate :title, /Foo page/
-          validate :element_presence, :login
+      context 'when sync is default' do
+        subject { web_page_class.opened? }
+        before do
+          web_page_class.class_eval do
+            include Singleton
+            element :login, '#id'
+            validate :url, /foo/
+            validate :title, /Foo page/
+            validate :element_presence, :login
+          end
+        end
+        context 'when all matches' do
+          before do
+            allow(web_page_class.instance).to receive(:current_url) { 'http://test.com/foo' }
+            allow(web_page_class.instance).to receive(:has_title?) { 'Foo page' }
+            allow(web_page_class.instance).to receive(:has_login_element?).with(no_args) { true }
+          end
+          it { is_expected.to be_truthy }
+        end
+        context 'when first validation fails' do
+          before do
+            expect(web_page_class.instance).to receive(:current_url).once { 'http://test.com/bar' }
+            expect(web_page_class.instance).to receive(:has_title?).never
+            allow(web_page_class).to receive(:has_login_element?).with(no_args).never
+          end
+          it { is_expected.to be_falsey }
         end
       end
-      context 'when all matches' do
+
+      context 'when sync is true' do
+        subject { web_page_class.opened?(sync: true) }
         before do
-          allow(web_page_class.instance).to receive(:current_url) { 'http://test.com/foo' }
-          allow(web_page_class.instance).to receive(:title) { 'Foo page' }
-          allow(web_page_class).to receive(:has_login_element?).with(no_args) { true }
+          web_page_class.class_eval do
+            include Singleton
+            element :login, '#id'
+            validate :url, /foo/
+            validate :title, /Foo page/
+            validate :element_presence, :login
+          end
+        end
+        context 'when all matches' do
+          before do
+            allow(web_page_class.instance).to receive(:current_url) { 'http://test.com/foo' }
+            allow(web_page_class.instance).to receive(:has_title?) { 'Foo page' }
+            allow(web_page_class.instance).to receive(:has_login_element?).with(no_args) { true }
+          end
+          it { is_expected.to be_truthy }
+        end
+        context 'when first validation fails' do
+          before do
+            expect(web_page_class.instance).to receive(:current_url).once { 'http://test.com/bar' }
+            expect(web_page_class.instance).to receive(:has_title?).never
+            allow(web_page_class).to receive(:has_login_element?).with(no_args).never
+          end
+          it { is_expected.to be_falsey }
         end
-        it { is_expected.to be_truthy }
       end
-      context 'when first validation fails' do
+
+      context 'when sync is false' do
+        subject { web_page_class.opened?(sync: false) }
         before do
-          expect(web_page_class.instance).to receive(:current_url).once { 'http://test.com/bar' }
-          expect(web_page_class.instance).to receive(:title).never
-          allow(web_page_class).to receive(:has_login_element?).with(no_args).never
+          web_page_class.class_eval do
+            include Singleton
+            element :login, '#id'
+            validate :url, /foo/
+            validate :title, /Foo page/
+            validate :element_presence, :login
+          end
+        end
+        context 'when all matches' do
+          before do
+            allow(web_page_class.instance).to receive(:current_url) { 'http://test.com/foo' }
+            allow(web_page_class.instance).to receive(:title) { 'Foo page' }
+            allow(web_page_class.instance).to receive(:has_no_login_element?).with(no_args) { false }
+          end
+          it { is_expected.to be_truthy }
+        end
+        context 'when first validation fails' do
+          before do
+            expect(web_page_class.instance).to receive(:current_url).once { 'http://test.com/bar' }
+            expect(web_page_class.instance).to receive(:title).never
+            allow(web_page_class).to receive(:has_no_login_element?).with(no_args).never
+          end
+          it { is_expected.to be_falsey }
         end
-        it { is_expected.to be_falsey }
       end
     end
   end
@@ -189,30 +241,21 @@ RSpec.describe Howitzer::Web::PageValidator do
     let!(:web_page1_class) do
       Class.new do
         include Howitzer::Web::PageValidator
-        def self.name
-          'TestWebPage1Class'
-        end
-
-        def self.opened?
-          true
-        end
       end
     end
-
     let!(:web_page2_class) do
       Class.new do
         include Howitzer::Web::PageValidator
-        def self.name
-          'TestWebPage2Class'
-        end
-
-        def self.opened?
-          false
-        end
       end
     end
     subject { web_page2_class.matched_pages }
-    before { described_class.instance_variable_set(:@pages, [web_page1_class, web_page2_class]) }
+    before do
+      allow(Howitzer::Web::PageValidator).to receive(:validations).with(no_args) do
+        { web_page1_class => 1, web_page2_class => 2 }
+      end
+      expect(web_page1_class).to receive(:opened?).with(sync: false) { true }
+      expect(web_page2_class).to receive(:opened?).with(sync: false) { false }
+    end
     it { is_expected.to eq([web_page1_class]) }
   end
 end