howitzer 2.0.0 → 2.0.1

data/lib/howitzer/web/page_validator.rb

@@ -16,13 +16,6 @@ module Howitzer
         @validations ||= {}
       end
 
-      # Returns page list
-      # @return [Array]
-
-      def self.pages
-        @pages ||= []
-      end
-
       # Checks if any validations are defined for the page
       # @raise  [Howitzer::NoValidationError] if no one validation is defined for the page
 
@@ -60,13 +53,13 @@ module Howitzer
         end
 
         # Check whether current page is opened or no
+        # @param sync [Boolean] if true then waits until validation true during Howitzer.capybara_wait_time
+        #   or returns false. If false, returns result immediately
         # @return [Boolean]
         # @raise  [Howitzer::NoValidationError] if no one validation is defined for the page
 
-        def opened?
-          if validations.present?
-            return !validations.any? { |(_, validation)| !validation.call(self) }
-          end
+        def opened?(sync: true)
+          return validations.all? { |(_, validation)| validation.call(self, sync) } if validations.present?
           raise Howitzer::NoValidationError, "No any page validation was found for '#{name}' page"
         end
 
@@ -74,30 +67,36 @@ module Howitzer
         # @return [Array] page name list
 
         def matched_pages
-          PageValidator.pages.select(&:opened?)
+          PageValidator.validations.keys.select { |klass| klass.opened?(sync: false) }
         end
 
         # @return [Hash] defined validations for current page class
 
         def validations
-          PageValidator.validations[name] ||= {}
+          PageValidator.validations[self] ||= {}
         end
 
         private
 
         def validate_element(element_name, value = nil)
           validations[:element_presence] =
-            ->(web_page) { web_page.public_send(*["has_#{element_name}_element?", value].compact) }
+            lambda do |web_page, sync|
+              if sync
+                web_page.instance.public_send(*["has_#{element_name}_element?", value].compact)
+              else
+                !web_page.instance.public_send(*["has_no_#{element_name}_element?", value].compact)
+              end
+            end
         end
 
         def validate_by_url(pattern)
           validations[:url] =
-            -> (web_page) { pattern === web_page.instance.current_url }
+            ->(web_page, _sync) { pattern === web_page.instance.current_url }
         end
 
         def validate_by_title(pattern)
           validations[:title] =
-            -> (web_page) { pattern === web_page.instance.title }
+            ->(web_page, sync) { sync ? web_page.instance.has_title?(pattern) : pattern === web_page.instance.title }
         end
 
         def validate_by_type(type, value, additional_value)

data/lib/howitzer/web/section_dsl.rb

@@ -1,18 +1,14 @@
+require 'howitzer/web/capybara_context_holder'
 module Howitzer
   module Web
     # This module combines section dsl methods
     module SectionDsl
+      include CapybaraContextHolder
+
       def self.included(base) #:nodoc:
         base.extend(ClassMethods)
       end
 
-      # Returns capybara context. For example, capybara session, parent element, etc.
-      # @abstract should be defined in parent context
-
-      def capybara_context
-        raise NotImplementedError, "Please define 'capybara_context' method for class holder"
-      end
-
       # This module holds section dsl class methods
       module ClassMethods
         # This class is for private usage only

data/spec/config/custom.yml

@@ -1,10 +1,10 @@
 log_dir: "spec/log"
 driver: selenium
 mailgun_domain: mailgun@test.domain
-mailgun_idle_timeout: 0.5
 mailgun_sleep_time: 0.05
 page_load_idle_timeout: 0.1
 capybara_wait_time: 5
 cloud_http_idle_timeout: 10
 hide_datetime_from_log: true
 maximized_window: false
+mailgun_idle_timeout: 0.5

data/spec/spec_helper.rb

@@ -69,11 +69,5 @@ Dir[File.join(__dir__, 'support', '**', '*.rb')].each { |f| require f }
 RSpec.configure do |config|
   config.include Howitzer::GeneratorHelper
   config.disable_monkey_patching = true
-  config.around(:each) do |ex|
-    $stdout = StringIO.new
-    $stderr = StringIO.new
-    ex.run
-    $stdout = STDOUT
-    $stderr = STDERR
-  end
+  config.around(:each, &:run)
 end

data/spec/support/shared_examples/capybara_context_holder.rb

@@ -12,8 +12,8 @@ RSpec.shared_examples :capybara_context_holder do
     context 'when parent class has the method' do
       before do
         web_page_class.class_eval do
-          def capybara_context
-            true
+          def capybara_scopes
+            @_scopes ||= [true]
           end
         end
       end
@@ -25,7 +25,7 @@ RSpec.shared_examples :capybara_context_holder do
       it 'should raise error' do
         expect { subject }.to raise_error(
           NotImplementedError,
-          "Please define 'capybara_context' method for class holder"
+          "Please define 'capybara_scopes' method for class holder"
         )
       end
     end

data/spec/support/shared_examples/element_dsl.rb

@@ -14,6 +14,9 @@ RSpec.shared_examples :element_dsl do
       it 'should create private :foo_elements instance method' do
         expect(klass_object.private_methods(false)).to include(:foo_elements)
       end
+      it 'should create private :wait_for_foo_element instance method' do
+        expect(klass_object.private_methods(false)).to include(:wait_for_foo_element)
+      end
       it 'should create public :has_foo_element? instance method' do
         expect(klass_object.public_methods(false)).to include(:has_foo_element?)
       end
@@ -37,6 +40,9 @@ RSpec.shared_examples :element_dsl do
       it 'should create private :foo_elements instance method' do
         expect(klass_object.private_methods(false)).to include(:foo_elements)
       end
+      it 'should create private :wait_for_foo_element instance method' do
+        expect(klass_object.private_methods(false)).to include(:wait_for_foo_element)
+      end
       it 'should create public :has_foo_element? instance method' do
         expect(klass_object.public_methods(false)).to include(:has_foo_element?)
       end
@@ -69,50 +75,154 @@ RSpec.shared_examples :element_dsl do
     before do
       allow(Capybara).to receive(:current_session) { kontext }
       klass.class_eval do
-        element :foo, :xpath, ->(title) { "//a[.='#{title}']" }
+        element :foo, :xpath, ->(title, name) { "//a[.='#{title}']/*[@name='#{name}']" }
         element :bar, '.someclass'
+        element :top_panel, '.top'
       end
     end
-    after { subject }
 
     describe '#name_element' do
       context 'when simple selector' do
-        subject { klass_object.send(:bar_element) }
-        it { expect(kontext).to receive(:find).with('.someclass') }
+        subject { klass_object.send(:bar_element, wait: 10) }
+        after { subject }
+        it { expect(klass_object.capybara_context).to receive(:find).with('.someclass', wait: 10) }
       end
       context 'when lambda selector' do
-        subject { klass_object.send(:foo_element, 'Hello') }
-        it { expect(kontext).to receive(:find).with(:xpath, "//a[.='Hello']") }
+        subject { klass_object.send(:foo_element, 'Hello', 'super', wait: 10) }
+        after { subject }
+        it do
+          expect(
+            klass_object.capybara_context
+          ).to receive(:find).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10)
+        end
+
+        context 'when several execution with different data' do
+          it 'does not cache previous data' do
+            expect(
+              klass_object.capybara_context
+            ).to receive(:find).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10).at_least(:once)
+            klass_object.send(:foo_element, 'Hello', 'super', wait: 10)
+
+            expect(
+              klass_object.capybara_context
+            ).to receive(:find).with(:xpath, "//a[.='Bye']/*[@name='puper']", wait: 15).at_least(:once)
+            klass_object.send(:foo_element, 'Bye', 'puper', wait: 15)
+          end
+        end
       end
     end
     describe '#name_elements' do
+      after { subject }
       context 'when simple selector' do
-        subject { klass_object.send(:bar_elements) }
-        it { expect(kontext).to receive(:all).with('.someclass') }
+        subject { klass_object.send(:bar_elements, wait: 10) }
+        it { expect(klass_object.capybara_context).to receive(:all).with('.someclass', wait: 10) }
       end
       context 'when lambda selector' do
-        subject { klass_object.send(:foo_elements, 'Hello') }
-        it { expect(kontext).to receive(:all).with(:xpath, "//a[.='Hello']") }
+        subject { klass_object.send(:foo_elements, 'Hello', 'super', wait: 10) }
+        it do
+          expect(
+            klass_object.capybara_context
+          ).to receive(:all).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10)
+        end
+      end
+    end
+    describe '#wait_for_name_element' do
+      context 'when simple selector' do
+        subject { klass_object.send(:wait_for_bar_element, wait: 10) }
+        it do
+          expect(klass_object.capybara_context).to receive(:find).with('.someclass', wait: 10)
+          is_expected.to eq(nil)
+        end
+      end
+      context 'when lambda selector' do
+        subject { klass_object.send(:wait_for_foo_element, 'Hello', 'super', wait: 10) }
+        it do
+          expect(
+            klass_object.capybara_context
+          ).to receive(:find).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10)
+          is_expected.to eq(nil)
+        end
+      end
+    end
+    describe '#within_name_element' do
+      let(:within_scope) { double }
+      after { subject }
+      context 'not nested' do
+        context 'when simple selector' do
+          subject do
+            klass_object.instance_eval do
+              within_bar_element(wait: 10) do
+                foo_element('Hello', 'super', wait: 10)
+              end
+            end
+          end
+          it do
+            expect(klass_object.capybara_context).to receive(:find).with('.someclass', wait: 10) { within_scope }
+            expect(within_scope).to receive(:find).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10)
+          end
+        end
+        context 'when lambda selector' do
+          subject do
+            klass_object.instance_eval do
+              within_foo_element('Hello', 'super', wait: 10) do
+                bar_element(wait: 10)
+              end
+            end
+          end
+          it do
+            expect(
+              klass_object.capybara_context
+            ).to receive(:find).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10) { within_scope }
+            expect(within_scope).to receive(:find).with('.someclass', wait: 10)
+          end
+        end
+      end
+      context 'nested' do
+        let(:nested_within_scope) { double }
+        subject do
+          klass_object.instance_eval do
+            within_top_panel_element(wait: 10) do
+              within_bar_element(wait: 10) do
+                foo_element('Hello', 'super', wait: 10)
+              end
+            end
+          end
+        end
+        it do
+          expect(klass_object.capybara_context).to receive(:find).with('.top', wait: 10) { within_scope }
+          expect(within_scope).to receive(:find).with('.someclass', wait: 10) { nested_within_scope }
+          expect(nested_within_scope).to receive(:find).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10)
+        end
       end
     end
     describe '#has_name_element?' do
+      after { subject }
       context 'when simple selector' do
-        subject { klass_object.send(:has_bar_element?) }
-        it { expect(kontext).to receive(:has_selector?).with('.someclass') }
+        subject { klass_object.send(:has_bar_element?, wait: 10) }
+        it { expect(klass_object.capybara_context).to receive(:has_selector?).with('.someclass', wait: 10) }
       end
       context 'when lambda selector' do
-        subject { klass_object.send(:has_foo_element?, 'Hello') }
-        it { expect(kontext).to receive(:has_selector?).with(:xpath, "//a[.='Hello']") }
+        subject { klass_object.send(:has_foo_element?, 'Hello', 'super', wait: 10) }
+        it do
+          expect(
+            klass_object.capybara_context
+          ).to receive(:has_selector?).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10)
+        end
       end
     end
     describe '#has_no_name_element?' do
+      after { subject }
       context 'when simple selector' do
-        subject { klass_object.send(:has_no_bar_element?) }
-        it { expect(kontext).to receive(:has_no_selector?).with('.someclass') }
+        subject { klass_object.send(:has_no_bar_element?, wait: 10) }
+        it { expect(klass_object.capybara_context).to receive(:has_no_selector?).with('.someclass', wait: 10) }
       end
       context 'when lambda selector' do
-        subject { klass_object.send(:has_no_foo_element?, 'Hello') }
-        it { expect(kontext).to receive(:has_no_selector?).with(:xpath, "//a[.='Hello']") }
+        subject { klass_object.send(:has_no_foo_element?, 'Hello', 'super', wait: 10) }
+        it do
+          expect(
+            klass_object.capybara_context
+          ).to receive(:has_no_selector?).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10)
+        end
       end
     end
   end

data/spec/unit/generators/base_generator_spec.rb

@@ -52,19 +52,19 @@ RSpec.describe Howitzer::BaseGenerator do
 
   describe '#manifest' do
     subject { described_class.new({}).manifest }
-    before { allow_any_instance_of(described_class).to receive(:initialize) { nil } }
-    it { is_expected.to be_nil }
+    before { allow_any_instance_of(described_class).to receive(:print_banner) { nil } }
+    it { is_expected.to eq([]) }
   end
 
   describe '#banner' do
     subject { described_class.new({}).send(:banner) }
-    before { allow_any_instance_of(described_class).to receive(:initialize) { nil } }
+    before { allow_any_instance_of(described_class).to receive(:print_banner) { nil } }
     it { is_expected.to be_nil }
   end
 
   describe '#logger' do
     subject { described_class.new({}).send(:logger) }
-    before { allow_any_instance_of(described_class).to receive(:initialize) { nil } }
+    before { allow_any_instance_of(described_class).to receive(:print_banner) { nil } }
     context 'when not specified' do
       before { described_class.instance_variable_set('@logger', nil) }
       it { is_expected.to eq($stdout) }
@@ -79,7 +79,7 @@ RSpec.describe Howitzer::BaseGenerator do
   describe '#destination' do
     subject { described_class.new({}).send(:destination) }
     before do
-      allow_any_instance_of(described_class).to receive(:initialize) { nil }
+      allow_any_instance_of(described_class).to receive(:print_banner) { nil }
       allow(described_class).to receive(:destination) { '/' }
     end
     it { is_expected.to eq('/') }
@@ -91,7 +91,7 @@ RSpec.describe Howitzer::BaseGenerator do
     let(:generator) { described_class.new({}) }
     subject { generator.send(:copy_files, list) }
     before do
-      allow_any_instance_of(described_class).to receive(:initialize) { nil }
+      allow_any_instance_of(described_class).to receive(:print_banner) { nil }
       allow(generator).to receive(:source_path).with(list.first[:source]) { source_path }
     end
     after { subject }
@@ -112,7 +112,7 @@ RSpec.describe Howitzer::BaseGenerator do
     let(:generator) { described_class.new('rspec' => true) }
     subject { generator.send(:copy_templates, list) }
     before do
-      allow_any_instance_of(described_class).to receive(:initialize) { nil }
+      allow_any_instance_of(described_class).to receive(:print_banner) { nil }
       allow(generator).to receive(:source_path).with(list.first[:source]) { source_path }
       allow(generator).to receive(:dest_path).with(list.first[:destination]) { destination_path }
       allow(generator).to receive(:write_template).with(destination_path, source_path)
@@ -147,13 +147,12 @@ RSpec.describe Howitzer::BaseGenerator do
     let(:generator) { described_class.new({}) }
     subject { generator.send(:print_banner) }
     before do
-      allow_any_instance_of(described_class).to receive(:initialize) { nil }
-      allow(generator).to receive(:banner) { banner }
+      allow_any_instance_of(described_class).to receive(:banner) { banner }
     end
     after { subject }
     context 'when banner present' do
       let(:banner) { 'banner' }
-      it { expect(described_class.logger).to receive(:puts).with(banner).once }
+      it { expect(described_class.logger).to receive(:puts).with(banner).twice }
     end
     context 'when banner blank' do
       let(:banner) { '' }
@@ -163,21 +162,21 @@ RSpec.describe Howitzer::BaseGenerator do
 
   describe '#print_info' do
     subject { described_class.new({}).send(:print_info, 'data') }
-    before { allow_any_instance_of(described_class).to receive(:initialize) { nil } }
+    before { allow_any_instance_of(described_class).to receive(:print_banner) { nil } }
     after { subject }
     it { expect(described_class.logger).to receive(:print).with('      data') }
   end
 
   describe '#puts_info' do
     subject { described_class.new({}).send(:puts_info, 'data') }
-    before { allow_any_instance_of(described_class).to receive(:initialize) { nil } }
+    before { allow_any_instance_of(described_class).to receive(:print_banner) { nil } }
     after { subject }
     it { expect(described_class.logger).to receive(:puts).with('      data') }
   end
 
   describe '#puts_error' do
     subject { described_class.new({}).send(:puts_error, 'data') }
-    before { allow_any_instance_of(described_class).to receive(:initialize) { nil } }
+    before { allow_any_instance_of(described_class).to receive(:print_banner) { nil } }
     after { subject }
     it { expect(described_class.logger).to receive(:puts).with('      ERROR: data') }
   end
@@ -185,14 +184,14 @@ RSpec.describe Howitzer::BaseGenerator do
   describe '#source_path' do
     subject { described_class.new({}).send(:source_path, 'example.txt') }
     before do
-      allow_any_instance_of(described_class).to receive(:initialize) { nil }
+      allow_any_instance_of(described_class).to receive(:print_banner) { nil }
     end
     it { is_expected.to include('/base/templates/example.txt') }
   end
 
   describe '#dest_path' do
     subject { described_class.new({}).send(:dest_path, 'example.txt') }
-    before { allow_any_instance_of(described_class).to receive(:initialize) { nil } }
+    before { allow_any_instance_of(described_class).to receive(:print_banner) { nil } }
     it { is_expected.to include('/example.txt') }
   end
 
@@ -203,7 +202,7 @@ RSpec.describe Howitzer::BaseGenerator do
     let(:dst) { '/path/to/d.txt' }
     subject { generator.send(:copy_with_path, data) }
     before do
-      allow_any_instance_of(described_class).to receive(:initialize) { nil }
+      allow_any_instance_of(described_class).to receive(:print_banner) { nil }
       allow(generator).to receive(:source_path).with('s.txt') { src }
       allow(generator).to receive(:dest_path).with('d.txt') { dst }
       allow(FileUtils).to receive(:mkdir_p).with('/path/to') { true }