howitzer 1.1.1 → 2.0.0

data/lib/howitzer/web/page_dsl.rb

@@ -0,0 +1,64 @@
+module Howitzer
+  module Web
+    # This module combines page dsl methods
+    module PageDsl
+      # This class is for private usage only
+      class PageScope
+        include RSpec::Matchers
+
+        def initialize(page_klass, &block)
+          self.page_klass = page_klass
+          instance_eval(&block)
+        end
+
+        # Makes current page as a subject for Rspec expectations
+        # @example
+        #  HomePage.on { expect(HomePage.given).to have_menu_section } # Bad
+        #  HomePage.on { is_expected.to have_menu_section } # Good
+
+        def is_expected # rubocop:disable Style/PredicateName
+          expect(page_klass.given)
+        end
+
+        # Proxies all methods to page instance except methods with be_ and have_ prefixes
+
+        def method_missing(name, *args, &block)
+          return super if name =~ /\A(?:be|have)_/
+          page_klass.given.send(name, *args, &block)
+        end
+
+        # Makes proxied methods to be evaludated and returned as a proc
+        # @see #method_missing
+
+        def respond_to_missing?(name, include_private = false)
+          !(name =~ /\A(?:be|have)_/) || super
+        end
+
+        private
+
+        attr_accessor :page_klass
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      # This module holds page dsl class methods
+      module ClassMethods
+        # Allows to execute page methods in context of the page.
+        # @note It additionally checks the page is really displayed
+        #   on each method call, otherwise it raises error
+        # @example
+        #   LoginPage.open
+        #   LoginPage.on do
+        #     fill_form(name: 'John', email: 'jkarpensky@gmail.com')
+        #     submit_form
+        #   end
+
+        def on(&block)
+          PageScope.new(self, &block)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/howitzer/web/page_validator.rb

@@ -0,0 +1,118 @@
+require 'howitzer/exceptions'
+
+module Howitzer
+  module Web
+    # This module combines page validation methods
+    module PageValidator
+      @validations = {}
+
+      def self.included(base) #:nodoc:
+        base.extend(ClassMethods)
+      end
+
+      # @return [Hash] defined validations for all page classes
+
+      def self.validations
+        @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
+
+      def check_validations_are_defined!
+        return if self.class.validations.present?
+
+        raise Howitzer::NoValidationError, "No any page validation was found for '#{self.class.name}' page"
+      end
+
+      # This module holds page validation class methods
+      module ClassMethods
+        # Adds validation to validation list for current page
+        # @param name [Symbol, String] a validation type. Possible values [:url, :element_presence, :title]
+        # @param value [Symbol, String, Regexp]
+        #   For :url and :title validation types must be <b>Regexp</b>
+        #   For :element_presence must be one of element names described for page
+        # @param additional_value [Object, nil] any value required to pass for a labmda selector
+        # @raise  [Howitzer::UnknownValidationError] if unknown validation type
+        # @example
+        #   class ArticleListPage < Howitzer::Web::Page
+        #     validate :title, /\ADemo web application - Listing Articles\z/
+        #   end
+        # @example
+        #   class ArticlePage < Howitzer::Web::Page
+        #     validate :url, %r{\/articles\/\d+\/?\z}
+        #   end
+        # @example
+        #   class HomePage < Howitzer::Web::Page
+        #     validate :element_presence, :menu_item, 'Logout'
+        #     element :menu_item, :xpath, ->(name) { ".//a[.='#{name}']" }
+        #   end
+
+        def validate(name, value, additional_value = nil)
+          validate_by_type(name, value, additional_value)
+        end
+
+        # Check whether current page is opened or no
+        # @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
+          raise Howitzer::NoValidationError, "No any page validation was found for '#{name}' page"
+        end
+
+        # Finds all matched pages which satisfy of defined validations on current page
+        # @return [Array] page name list
+
+        def matched_pages
+          PageValidator.pages.select(&:opened?)
+        end
+
+        # @return [Hash] defined validations for current page class
+
+        def validations
+          PageValidator.validations[name] ||= {}
+        end
+
+        private
+
+        def validate_element(element_name, value = nil)
+          validations[:element_presence] =
+            ->(web_page) { web_page.public_send(*["has_#{element_name}_element?", value].compact) }
+        end
+
+        def validate_by_url(pattern)
+          validations[:url] =
+            -> (web_page) { pattern === web_page.instance.current_url }
+        end
+
+        def validate_by_title(pattern)
+          validations[:title] =
+            -> (web_page) { pattern === web_page.instance.title }
+        end
+
+        def validate_by_type(type, value, additional_value)
+          case type.to_s.to_sym
+            when :url
+              validate_by_url(value)
+            when :element_presence
+              validate_element(value, additional_value)
+            when :title
+              validate_by_title(value)
+            else
+              raise Howitzer::UnknownValidationError, "unknown '#{type}' validation type"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/howitzer/web/section.rb

@@ -0,0 +1,27 @@
+require 'howitzer/web/base_section'
+
+module Howitzer
+  module Web
+    # This class uses for named sections which possible to reuse in different pages
+    class Section < BaseSection
+      class << self
+        protected
+
+        # DSL method which specifies section container selector represented by HTML element.
+        # Any elements described in sections will start in this HTML element.
+        # @param args [Array] original Capybara arguments. For details, see `Capybara::Node::Finders#all.
+        # @raise [ArgumentError] if no arguments were passed
+        # @example
+        #   class MenuSection < Howitzer::Web::Section
+        #     me :xpath, ".//*[@id='panel']"
+        #   end
+        # @!visibility public
+
+        def me(*args)
+          raise ArgumentError, 'Finder arguments are missing' if args.blank?
+          @default_finder_args = args
+        end
+      end
+    end
+  end
+end

data/lib/howitzer/web/section_dsl.rb

@@ -0,0 +1,154 @@
+module Howitzer
+  module Web
+    # This module combines section dsl methods
+    module SectionDsl
+      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
+        class SectionScope
+          attr_accessor :section_class
+
+          # Instantiates an anynomous or named section and executes block code in the section scope
+
+          def initialize(name, *args, &block)
+            @args = args
+            self.section_class =
+              if block
+                Class.new(Howitzer::Web::BaseSection)
+              else
+                "#{name}_section".classify.constantize
+              end
+            instance_eval(&block) if block_given?
+          end
+
+          # # Defines an element on the section
+          # # @see Howitzer::PageDsl::ClassMethods#element
+
+          def element(*args)
+            section_class.send(:element, *args)
+          end
+
+          # Delegates a section describing to the section class
+
+          def section(name, *args, &block)
+            section_class.send(:section, name, *args, &block)
+          end
+
+          # Returns a selector for the section.
+          # @note If anonymous section uses, then inline selector should be specified.
+          #   Otherwise arguments should be defined with `.me` dsl method in named section
+          # @return [Array]
+          # @raise [ArgumentError] when finder arguments were not specified
+
+          def finder_args
+            @finder_args ||= begin
+              return @args if @args.present?
+              section_class.default_finder_args || raise(ArgumentError, 'Missing finder arguments')
+            end
+          end
+        end
+
+        protected
+
+        # DSL method which defines named or anonymous section within a page or a section
+        # @note This method generates following dynamic methods:
+        #
+        #   <b><em>section_name</em>_section</b> - equals capybara #find(...) method
+        #
+        #   <b><em>section_name</em>_sections</b> - equals capybara #all(...) method
+        #
+        #   <b><em>section_name</em>_sections.first</b> - equals capybara #first(...) method
+        #
+        #   <b>has_<em>section_name</em>_section?</b> - equals capybara #has_selector(...) method
+        #
+        #   <b>has_no_<em>section_name</em>_section?</b> - equals capybara #has_no_selector(...) method
+        # @note It is possible to use nested anonymous sections
+        # @param name [Symbol, String] an unique section name
+        # @param args [Array] original Capybara arguments. For details, see `Capybara::Node::Finders#all.
+        #  (In most cases should be ommited for named sections because the section selector is specified
+        #  with `#me` method. But must be specified for anonymous sections)
+        # @param block [Proc] this block can contain nested sections and elements
+        # @example Named section
+        #   class MenuSection < Howitzer::Web::Section
+        #     me :xpath, ".//*[@id='panel']"
+        #   end
+        #   class HomePage < Howitzer::Web::Page
+        #     section :menu
+        #   end
+        #   HomePage.on { is_expected.to have_menu_section }
+        # @example Anonymous section
+        #   class HomePage < Howitzer::Web::Page
+        #     section :info_panel, '#panel' do
+        #       element :edit_button, '.edit'
+        #       element :title_field, '.title'
+        #
+        #       def edit_info(title: nil)
+        #         edit_button_element.click
+        #         title_field_element.set(title)
+        #       end
+        #     end
+        #   end
+        #   HomePage.on { info_panel.edit_info(title: 'Test Title') }
+        # @example Anonymous nested section
+        #   class HomePage < Howitzer::Web::Page
+        #     section :info_panel, '#panel' do
+        #       element :edit_button, '.edit'
+        #
+        #       section :form, '.form' do
+        #         element :title_field, '.title'
+        #       end
+        #     end
+        #   end
+        #   HomePage.on { info_panel_section.edit_info(title: 'Test Title') }
+        # @!visibility public
+
+        def section(name, *args, &block)
+          scope = SectionScope.new(name, *args, &block)
+          define_section_method(scope.section_class, name, scope.finder_args)
+          define_sections_method(scope.section_class, name, scope.finder_args)
+          define_has_section_method(name, scope.finder_args)
+          define_has_no_section_method(name, scope.finder_args)
+        end
+
+        private
+
+        def define_section_method(klass, name, args)
+          define_method("#{name}_section") do
+            klass.new(self, capybara_context.find(*args))
+          end
+        end
+
+        def define_sections_method(klass, name, args)
+          define_method("#{name}_sections") do
+            capybara_context.all(*args).map { |el| klass.new(self, el) }
+          end
+        end
+
+        def define_has_section_method(name, args)
+          define_method("has_#{name}_section?") do
+            capybara_context.has_selector?(*args)
+          end
+        end
+
+        def define_has_no_section_method(name, args)
+          define_method("has_no_#{name}_section?") do
+            capybara_context.has_no_selector?(*args)
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'howitzer/web/base_section'

data/spec/config/custom.yml

@@ -1 +1,10 @@
-txt_log: log.txt
+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

data/spec/spec_helper.rb

@@ -2,23 +2,13 @@ require 'rubygems'
 require 'bundler/setup'
 require 'simplecov'
 require 'coveralls'
-require 'tmpdir'
-require 'ffaker'
-require 'capybara'
-require 'json'
-require 'capybara/dsl'
-require 'active_support'
-require 'active_support/deprecation'
-require 'active_support/deprecation/method_wrappers'
-require 'active_support/core_ext'
-require 'repeater'
-require 'howitzer/exceptions'
-require 'howitzer/utils/log'
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+Coveralls.wear!
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
+  [
     SimpleCov::Formatter::HTMLFormatter,
     Coveralls::SimpleCov::Formatter
-]
+  ]
+)
 
 SimpleCov.start do
   add_filter '/spec/'
@@ -30,8 +20,36 @@ SimpleCov.start do
   add_group 'lib', '/lib'
 end
 
+require 'tmpdir'
+require 'ffaker'
+require 'capybara'
+require 'json'
+require 'capybara/dsl'
+require 'active_support'
+require 'active_support/deprecation'
+require 'active_support/deprecation/method_wrappers'
+require 'active_support/core_ext'
+require 'repeater'
+require 'sexy_settings'
+
+SexySettings.configure do |config|
+  config.path_to_default_settings = File.expand_path(
+    'default.yml',
+    File.join(__dir__, '..', 'generators', 'config', 'templates')
+  )
+  config.path_to_custom_settings = File.expand_path(
+    'custom.yml',
+    File.join(__dir__, 'config')
+  )
+end
+
+puts SexySettings::Base.instance.as_formatted_text
+
+require 'howitzer'
+require 'howitzer/exceptions'
+
 def project_path
-  File.expand_path(File.join(File.dirname(__FILE__), '..'))
+  File.expand_path(File.join(__dir__, '..'))
 end
 
 def lib_path
@@ -46,10 +64,10 @@ def log_path
   File.join(project_path, 'spec/log')
 end
 
-Dir[File.join(File.dirname(__FILE__), 'support', '**', '*.rb')].each{ |f| require f }
+Dir[File.join(__dir__, 'support', '**', '*.rb')].each { |f| require f }
 
 RSpec.configure do |config|
-  config.include GeneratorHelper
+  config.include Howitzer::GeneratorHelper
   config.disable_monkey_patching = true
   config.around(:each) do |ex|
     $stdout = StringIO.new
@@ -58,4 +76,4 @@ RSpec.configure do |config|
     $stdout = STDOUT
     $stderr = STDERR
   end
-end
+end