howitzer 1.1.1 → 2.0.0

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

@@ -1,107 +0,0 @@
-require 'spec_helper'
-require 'howitzer/utils/log'
-include LoggerHelper
-
-RSpec.describe 'Logger' do
-  let(:path) { File.join(log_path,'log.txt') }
-  context '#log' do
-    subject { log }
-    let(:other_log) { Howitzer::Log.instance }
-    it { is_expected.to be_a_kind_of(Howitzer::Log) }
-    it { is_expected.to equal(other_log) }
-  end
-
-  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 { is_expected.to include(expected_result) }
-  end
-
-  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
-      expect(settings).to receive(:as_formatted_text).and_return(formatted_text)
-      log.settings_as_formatted_text
-    end
-    after { clear_file(path) }
-    it { is_expected.to include(expected_result) }
-  end
-
-  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 { is_expected.to include(expected_result) }
-  end
-
-  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') }
-      end
-      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
-        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') }
-      end
-      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
-      subject { log.error(*args) }
-      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') }
-      end
-      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') }
-      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'] }
-        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
-        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
-        let(:args) { [123,123] }
-        it { expect{subject}.to raise_error(TypeError) }
-      end
-    end
-    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'] }
-        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') }
-      end
-    end
-  end
-end

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

@@ -1,265 +0,0 @@
-require 'spec_helper'
-require 'howitzer/utils/page_validator'
-require 'howitzer/utils/locator_store'
-
-RSpec.describe Howitzer::Utils::PageValidator do
-  describe '.validations' do
-    it { expect(subject.validations).to eql({}) }
-  end
-end
-
-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
-    subject { web_page.check_validations_are_defined! }
-    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' }
-      it do
-        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
-      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 { expect{subject}.to_not raise_error }
-    end
-  end
-
-  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/} }
-            it do
-              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
-            let(:options) { {pattern: /foo/} }
-            it do
-              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
-            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'} }
-            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
-        end
-      end
-      context 'as symbol' do
-        let(:name) { :url }
-        let(:options) { {pattern: /foo/} }
-        it do
-          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
-      let(:name) { :element_presence }
-      context 'when options is correct' do
-        context '(as string)' do
-          let(:options) { {'locator' => 'test_locator'} }
-          it do
-            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
-          let(:options) { {locator: :test_locator} }
-          it do
-            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
-          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: ''} }
-          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
-            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
-          let(:options) { {pattern: /foo/} }
-          it do
-            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
-          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'} }
-          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 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 { is_expected.to eq([]) }
-    it do
-      subject << Class
-      is_expected.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 { is_expected.to be_truthy }
-      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 { is_expected.to be_falsey }
-      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 { is_expected.to eq([web_page1_class]) }
-  end
-end

data/spec/unit/lib/web_page_spec.rb

@@ -1,346 +0,0 @@
-require 'spec_helper'
-require 'howitzer/web_page'
-require 'howitzer/capybara/settings'
-
-RSpec.describe 'WebPage' do
-  describe '.open' do
-    let(:url_value) { 'google.com' }
-    let(:retryable) { double }
-    let(:check_correct_page_loaded) { double }
-    let(:other_instance) { WebPage.instance }
-    subject { WebPage.open(url_value) }
-    it do
-      expect(log).to receive(:info).with("Open WebPage page by 'google.com' url").once.ordered
-      expect(WebPage).to receive(:retryable).ordered.once.and_call_original
-      expect(WebPage).to receive(:visit).with(url_value).once.ordered
-      expect(WebPage).to receive(:given).once.ordered
-      subject
-    end
-  end
-
-  describe '.given' do
-    subject { WebPage.given }
-    before do
-      expect(WebPage).to receive(:wait_for_opened).with(no_args).once
-      expect(WebPage).to receive(:instance) { true }
-    end
-    it { is_expected.to be_truthy }
-  end
-
-  describe '.title' do
-    let(:page) { double }
-    subject { WebPage.instance.title }
-    before do
-      allow_any_instance_of(WebPage).to receive(:check_validations_are_defined!) { true }
-      allow(WebPage.instance).to receive(:current_url) { 'google.com' }
-    end
-    it do
-      expect(WebPage.instance).to receive(:page) { page }
-      expect(page).to receive(:title)
-      subject
-    end
-  end
-
-  describe '.url' do
-    let(:page) { double }
-    subject { WebPage.url }
-    it do
-      expect(WebPage).to receive(:page) { page }
-      expect(page).to receive(:current_url) { 'google.com' }
-      is_expected.to eq('google.com')
-    end
-  end
-
-  describe '.current_url' do
-    let(:page) { double }
-    subject { WebPage.current_url }
-    it do
-      expect(WebPage).to receive(:page) { page }
-      expect(page).to receive(:current_url) { 'google.com' }
-      is_expected.to eq('google.com')
-    end
-  end
-
-  describe '.text' do
-    let(:page) { double }
-    let(:find) { double }
-    subject { WebPage.text }
-    it do
-      expect(WebPage).to receive(:page) { page }
-      expect(page).to receive(:find).with('body') { find }
-      expect(find).to receive(:text) { 'some body text' }
-      is_expected.to eq('some body text')
-    end
-  end
-
-  describe '.current_page' do
-    subject { WebPage.current_page }
-    context 'when matched_pages has no pages' do
-      before { allow(WebPage).to receive(:matched_pages){ [] } }
-      it { is_expected.to eq(WebPage::UnknownPage) }
-    end
-    context 'when matched_pages has more than 1 page' do
-      let(:foo_page) { double(inspect: 'FooPage') }
-      let(:bar_page) { double(inspect: 'BarPage') }
-      before do
-        allow(WebPage).to receive(:current_url) { 'http://test.com' }
-        allow(WebPage).to receive(:title) { 'Test site' }
-        allow(WebPage).to receive(:matched_pages){ [foo_page, bar_page] }
-      end
-      it do
-        expect(log).to receive(:error).with(
-          Howitzer::AmbiguousPageMatchingError,
-          "Current page matches more that one page class (FooPage, BarPage).\n\tCurrent url: http://test.com\n\tCurrent title: Test site"
-        ).once
-        subject
-      end
-    end
-    context 'when matched_pages has only 1 page' do
-      let(:foo_page) { double(to_s: 'FooPage') }
-      before { allow(WebPage).to receive(:matched_pages){ [foo_page] } }
-      it { is_expected.to eq(foo_page) }
-    end
-  end
-
-  describe '.wait_for_opened' do
-    subject { WebPage.wait_for_opened }
-    context 'when page is opened' do
-      before { allow(WebPage).to receive(:opened?) { true } }
-      it { is_expected.to be_nil }
-    end
-    context 'when page is not opened' do
-      before do
-        allow(WebPage).to receive(:current_page) { 'FooPage' }
-        allow(WebPage).to receive(:current_url) { 'http://test.com' }
-        allow(WebPage).to receive(:title) { 'Test site' }
-        allow(settings).to receive(:timeout_small) { 0.1 }
-        allow(WebPage).to receive(:opened?) { false }
-      end
-      it do
-        expect(log).to receive(:error).with(
-          Howitzer::IncorrectPageError,
-          "Current page: FooPage, expected: WebPage.\n\tCurrent url: http://test.com\n\tCurrent title: Test site"
-        )
-        subject
-      end
-    end
-  end
-
-  describe '#initialize' do
-    subject { WebPage.send(:new) }
-    before do
-      expect_any_instance_of(WebPage).to receive(:check_validations_are_defined!).once { true }
-    end
-    context 'when maximized_window is true' do
-      before { allow(settings).to receive(:maximized_window) { true } }
-      it do
-        expect_any_instance_of(WebPage).to receive_message_chain('page.driver.browser.manage.window.maximize')
-        subject
-      end
-    end
-    context 'when maximized_window is false' do
-      before { allow(settings).to receive(:maximized_window) { false } }
-      it do
-        expect_any_instance_of(WebPage).not_to receive('page')
-        subject
-      end
-    end
-  end
-
-  describe 'inherited callback' do
-    let!(:page_class) do
-      Howitzer::Utils::PageValidator.instance_variable_set(:@pages, [])
-      Class.new(WebPage)
-    end
-    it { expect(Howitzer::Utils::PageValidator.pages).to eq([page_class]) }
-    it 'can not be instantiated with new' do
-      expect { page_class.new }.to raise_error(NoMethodError, "private method `new' called for #{page_class}")
-    end
-  end
-
-  describe '#tinymce_fill_in' do
-    subject { WebPage.instance.tinymce_fill_in(name,options) }
-    let(:name) { 'name' }
-    let(:options) { {with: 'some content'} }
-    before do
-      allow(WebPage.instance).to receive(:current_url) { 'google.com' }
-      allow(settings).to receive(:driver) { driver_name }
-    end
-    context 'when correct driver specified' do
-      let(:driver_name) { 'selenium' }
-      let(:page) { double }
-      let(:driver) { double }
-      let(:browser) { double }
-      let(:switch_to) { double }
-      let(:find) { double }
-      let(:native) { double }
-      it do
-        expect(WebPage.instance).to receive(:page).exactly(3).times { page }
-        expect(page).to receive(:driver).ordered { driver }
-        expect(driver).to receive(:browser).ordered { browser }
-        expect(browser).to receive(:switch_to).ordered { switch_to }
-        expect(switch_to).to receive(:frame).with('name_ifr').once
-
-        expect(page).to receive(:find).with(:css, '#tinymce').ordered { find }
-        expect(find).to receive(:native).ordered { native }
-        expect(native).to receive(:send_keys).with('some content').once
-
-        expect(page).to receive(:driver) { driver }
-        expect(driver).to receive(:browser) { browser }
-        expect(browser).to receive(:switch_to) { switch_to }
-        expect(switch_to).to receive(:default_content)
-
-        subject
-      end
-    end
-    context 'when incorrect driver specified' do
-      let(:driver_name) { 'ff' }
-      let(:page) { double }
-      it do
-        expect(WebPage.instance).to receive(:page) { page }
-        expect(page).to receive(:execute_script).with("tinyMCE.get('name').setContent('some content')")
-        subject
-      end
-    end
-  end
-  describe '#click_alert_box' do
-    subject { WebPage.instance.click_alert_box(flag_value) }
-    before do
-      allow(settings).to receive(:driver) { driver_name }
-      allow(settings).to receive(:timeout_tiny) { 0 }
-      allow(WebPage.instance).to receive(:current_url) { 'google.com' }
-    end
-    context 'when flag true and correct driver specified' do
-      let(:flag_value) { true }
-      let(:page) { double }
-      let(:alert) { double }
-      let(:driver) { double }
-      let(:browser) { double }
-      let(:switch_to) { double }
-      let(:driver_name) { 'selenium' }
-      it do
-        expect(WebPage.instance).to receive(:page) { page }
-        expect(page).to receive(:driver).ordered { driver }
-        expect(driver).to receive(:browser).ordered { browser }
-        expect(browser).to receive(:switch_to).ordered { switch_to }
-        expect(switch_to).to receive(:alert).ordered { alert }
-        expect(alert).to receive(:accept).once
-        subject
-      end
-    end
-    context 'when flag false and correct driver specified' do
-      let(:flag_value) { false }
-      let(:page) { double }
-      let(:alert) { double }
-      let(:driver) { double }
-      let(:browser) { double }
-      let(:switch_to) { double }
-      let(:driver_name) { 'selenium' }
-      it do
-        expect(WebPage.instance).to receive(:page) { page }
-        expect(page).to receive(:driver).ordered { driver }
-        expect(driver).to receive(:browser).ordered { browser }
-        expect(browser).to receive(:switch_to).ordered { switch_to }
-        expect(switch_to).to receive(:alert).ordered { alert }
-        expect(alert).to receive(:dismiss).once
-        subject
-      end
-    end
-    context 'when flag true and wrong driver specified' do
-      let(:flag_value) { true }
-      let(:page) { double }
-      let(:driver_name) { 'ff' }
-      it do
-        expect(WebPage.instance).to receive(:page) { page }
-        expect(page).to receive(:evaluate_script).with('window.confirm = function() { return true; }')
-        subject
-      end
-    end
-    context 'when flag false and wrong driver specified' do
-      let(:driver_name) { 'ff' }
-      let(:flag_value) { false }
-      let(:page) { double }
-      it do
-        expect(WebPage.instance).to receive(:page) { page }
-        expect(page).to receive(:evaluate_script).with('window.confirm = function() { return false; }')
-        subject
-      end
-    end
-  end
-
-  describe '#js_click' do
-    subject { WebPage.instance.js_click('.some_class') }
-    before do
-      allow(settings).to receive(:timeout_tiny) { 0.1 }
-      allow(WebPage.instance).to receive(:current_url) { 'google.com' }
-    end
-    let(:page) { double }
-    it do
-      expect(WebPage.instance).to receive(:page) { page }
-      expect(page).to receive(:execute_script).with("$('.some_class').trigger('click')")
-      subject
-    end
-
-  end
-
-  describe '#wait_for_title' do
-    subject { WebPage.instance.wait_for_title(expected_title) }
-    before do
-      allow(settings).to receive(:timeout_small) { 0.1 }
-      allow(WebPage.instance).to receive(:title) { 'title' }
-    end
-    context 'when title equals expected title' do
-      let(:expected_title) { 'title' }
-      it do
-        is_expected.to be_truthy
-      end
-    end
-    context 'when title not equals expected title' do
-      let(:expected_title) { 'bad title' }
-      let(:error) { Howitzer::IncorrectPageError }
-      let(:error_message) { 'Current title: title, expected:  bad title' }
-      it do
-        expect(log).to receive(:error).with(error,error_message).once.and_call_original
-        expect { subject }.to raise_error(error)
-      end
-    end
-  end
-
-  describe '#wait_for_url' do
-    subject { WebPage.instance.wait_for_url(expected_url) }
-    before do
-      allow(settings).to receive(:timeout_small) { 0.1 }
-      allow(WebPage.instance).to receive(:current_url) { 'google.com' }
-    end
-    context 'when current_url equals expected_url' do
-      let(:expected_url) { 'google.com' }
-      it { is_expected.to be_truthy }
-    end
-    context 'when current_url not equals expected_url' do
-      let(:expected_url) { 'bad_url' }
-      let(:error) { Howitzer::IncorrectPageError }
-      let(:error_message) { "Current url: google.com, expected:  #{expected_url}"  }
-      it do
-        expect(log).to receive(:error).with(error, error_message).once.and_call_original
-        expect { subject }.to raise_error(error)
-      end
-    end
-  end
-
-  describe '#reload' do
-    let(:wait_for_url) { double }
-    subject { WebPage.instance.reload }
-    let(:visit) { double }
-    let(:webpage) { double }
-    before do
-      allow(WebPage.instance).to receive(:current_url) { 'google.com' }
-      stub_const('WebPage::URL_PATTERN', 'pattern')
-      allow(wait_for_url).to receive('pattern') { true }
-    end
-    it do
-      expect(log).to receive(:info) { "Reload 'google.com'" }
-      expect(WebPage.instance).to receive(:visit).with('google.com')
-      subject
-    end
-  end
-end