howitzer 0.0.3 → 1.0.1

data/lib/howitzer/utils/log.rb

@@ -0,0 +1,137 @@
+require 'log4r'
+require 'fileutils'
+
+module Howitzer
+  class Log
+    include Singleton
+    include Log4r
+
+    [:debug, :info, :warn, :fatal].each do |method_name|
+      define_method method_name do |text|
+        @logger.send(method_name, text)
+      end
+    end
+
+    ##
+    #
+    # Prints log entry about error with ERROR severity
+    # *Examples:*
+    #  log.error MyException, 'Some error text', caller
+    #  log.error 'Some error text', caller
+    #  log.error MyException, 'Some caller text'
+    #  log.error 'Some error text'
+    #  log.error err_object
+    #
+    # *Parameters:*
+    # * +args+ - see example
+    #
+
+    def error(*args)
+      object = if args.first.nil?
+        $!
+      else
+        case args.size
+          when 1
+           args.first.is_a?(Exception) ? args.first : RuntimeError.new(args.first)
+          when 2
+            if args.first.is_a?(Class) && args.first < Exception
+              args.first.new(args.last)
+            else
+              exception = RuntimeError.new(args.first)
+              exception.set_backtrace(args.last)
+              exception
+            end
+          when 3
+           exception = args.first.new(args[1])
+           exception.set_backtrace(args.last)
+           exception
+          else nil
+        end
+      end
+      err_backtrace = object.backtrace ? "\n\t#{object.backtrace.join("\n\t")}" : nil
+      @logger.error("[#{object.class}] #{object.message}#{err_backtrace}")
+      fail(object)
+    end
+
+    ##
+    #
+    # Prints feature name into log with INFO severity
+    #
+    # *Parameters:*
+    # * +text+ - Feature name
+    #
+
+    def print_feature_name(text)
+      log_without_formatting{ info "*** Feature: #{text.upcase} ***" }
+    end
+
+    ##
+    #
+    # Returns formatted howitzer settings
+    #
+
+    def settings_as_formatted_text
+      log_without_formatting{ info settings.as_formatted_text }
+    end
+
+    ##
+    #
+    # Prints scenario name into log with INFO severity
+    #
+    # *Parameters:*
+    # * +text+ - Scenario name
+    #
+    def print_scenario_name(text)
+      log_without_formatting{ info " => Scenario: #{text}" }
+    end
+
+    private
+
+    def initialize
+      @logger = Logger.new("ruby_log")
+      @logger.add(console_log)
+      @logger.add(error_log)
+      @logger.add(txt_log)
+      self.base_formatter = default_formatter
+      Logger["ruby_log"].level = settings.debug_mode ? ALL : INFO
+      Logger["ruby_log"].trace = true
+    end
+
+    def log_without_formatting
+      self.base_formatter = blank_formatter
+      yield
+      self.base_formatter = default_formatter
+    end
+
+    def console_log
+      StdoutOutputter.new(:console).tap{|o| o.only_at(INFO, DEBUG, WARN)}
+    end
+
+    def error_log
+      StderrOutputter.new(:error, 'level' => ERROR)
+    end
+
+    def txt_log
+      FileUtils.mkdir_p(settings.log_dir) unless File.exists?(settings.log_dir)
+      filename = File.join(settings.log_dir, settings.txt_log)
+      FileOutputter.new(:txt_log, :filename => filename, :trunc => true)
+    end
+
+    def blank_formatter
+      PatternFormatter.new(:pattern => "%m")
+    end
+
+    def default_formatter
+      if settings.hide_datetime_from_log
+        params = {pattern: "[%l] %m"}
+      else
+        params = {pattern: "%d [%l] :: %m", date_pattern: "%Y/%m/%d %H:%M:%S"}
+      end
+      PatternFormatter.new(params)
+    end
+
+    def base_formatter=(formatter)
+      @logger.outputters.each {|outputter| outputter.formatter = formatter}
+    end
+  end
+end

data/lib/howitzer/utils/page_validator.rb

@@ -0,0 +1,86 @@
+module Howitzer
+  module Utils
+    module PageValidator
+      WrongOptionError = Class.new(StandardError)
+      NoValidationError = Class.new(StandardError)
+      UnknownValidationName = Class.new(StandardError)
+      @validations = {}
+
+      ##
+      #
+      # Returns validation list
+      #
+      # @return [Hash]
+      #
+      def self.validations
+        @validations
+      end
+
+      def self.included(base)  #:nodoc:
+        base.extend(ClassMethods)
+      end
+
+      ##
+      #
+      # Checks that correct page has been loaded
+      #
+      # @raise  [Howitzer::Utils::PageValidator::NoValidationError]   If no validation was specified
+      #
+      def check_correct_page_loaded
+        validations = PageValidator.validations[self.class.name]
+        raise NoValidationError, "No any page validation was found" if validations.nil?
+        validations.each {|(_, validation)| validation.call(self)}
+      end
+
+      module ClassMethods
+
+        ##
+        #
+        # Adds validation to validation list
+        #
+        # @param [Symbol or String] name                                    Which validation type. Possible values [:url, :element_presence, :title]
+        # @option options [Hash]                                            Validation options
+        #    :pattern => [Regexp]                                             For :url and :title validation types
+        #    :locator => [String]                                             For :element_presence (Existing locator name)
+        # @raise  [Howitzer::Utils::PageValidator::UnknownValidationName]   If unknown validation type was passed
+        #
+        def validates(name, options)
+          raise TypeError, "Expected options to be Hash, actual is '#{options.class}'" unless options.class == Hash
+          PageValidator.validations[self.name] ||= {}
+          case name.to_sym
+            when :url
+              validate_url options
+            when :element_presence
+              validate_element options
+            when :title
+              validate_title options
+            else
+              raise UnknownValidationName, "unknown '#{name}' validation name"
+          end
+        end
+
+        private
+
+        def validate_url(options)
+          pattern = options[:pattern] || options["pattern"]
+          raise WrongOptionError, "Please specify ':pattern' option as Regexp object" if pattern.nil? || !pattern.is_a?(Regexp)
+          PageValidator.validations[self.name][:url] = lambda { |web_page| web_page.wait_for_url(pattern) }
+        end
+
+        def validate_element(options)
+          locator = options[:locator] || options["locator"]
+          raise WrongOptionError, "Please specify ':locator' option as one of page locator names" if locator.nil? || locator.empty?
+          PageValidator.validations[self.name][:element_presence] = lambda { |web_page| web_page.find_element(locator) }
+        end
+
+        def validate_title(options)
+          pattern = options[:pattern] || options["pattern"]
+          raise WrongOptionError, "Please specify ':pattern' option as Regexp object" if pattern.nil? || !pattern.is_a?(Regexp)
+          PageValidator.validations[self.name][:title] = lambda { |web_page| web_page.wait_for_title(pattern) }
+        end
+
+      end
+    end
+
+  end
+end

data/lib/howitzer/version.rb

@@ -1,3 +1,3 @@
 module Howitzer
-  VERSION = "0.0.3"
-end
+  VERSION = "1.0.1"
+end

data/lib/howitzer/web_page.rb

@@ -1,62 +1,202 @@
 require "rspec/expectations"
-require 'howitzer/utils/locator_store'
+require "howitzer/utils/locator_store"
+require "howitzer/utils/page_validator"
+require "singleton"
 
 class WebPage
 
   BLANK_PAGE = 'about:blank'
+  IncorrectPageError = Class.new(StandardError)
 
-  #TODO include Capybara DSL here
   include LocatorStore
+  include Howitzer::Utils::PageValidator
   include RSpec::Matchers
+  include Capybara::DSL
+  extend  Capybara::DSL
+  include Singleton
 
-  def self.open(url="#{settings.app_url}#{self::URL}")
+  def self.inherited(subclass)
+    subclass.class_eval { include Singleton }
+  end
+
+  ##
+  #
+  # Opens web-site by given url
+  #
+  # *Parameters:*
+  # * +url+ - Url string that will be opened
+  #
+  # *Returns:*
+  # * +WebPage+ - New instance of current class
+  #
+
+  def self.open(url="#{app_url}#{self::URL}")
     log.info "Open #{self.name} page by '#{url}' url"
     retryable(tries: 2, logger: log, trace: true, on: Exception) do |retries|
       log.info "Retry..." unless retries.zero?
       visit url
     end
-    new
+    given
   end
 
+  ##
+  #
+  # Returns singleton instance of current web page
+  #
+  # *Returns:*
+  # * +WebPage+ - Singleton instance
+  #
+
   def self.given
-    new
+    self.instance.tap{ |page| page.check_correct_page_loaded }
   end
 
+  ##
+  #
+  # Fills in field that using Tinymce API
+  #
+  # *Parameters:*
+  # * +name+ - Frame name that contains Tinymce field
+  # * +Hash+ - Not required options
+  #
+
+  def tinymce_fill_in(name, options = {})
+    if %w[selenium selenium_dev sauce].include? settings.driver
+      page.driver.browser.switch_to.frame("#{name}_ifr")
+      page.find(:css, '#tinymce').native.send_keys(options[:with])
+      page.driver.browser.switch_to.default_content
+    else
+      page.execute_script("tinyMCE.get('#{name}').setContent('#{options[:with]}')")
+    end
+  end
+
+  ##
+  #
+  # Accepts or declines JS alert box by given flag
+  #
+  # *Parameters:*
+  # * +flag+ [TrueClass,FalseClass] - Determines accept or decline alert box
+  #
+
+   def click_alert_box(flag)
+    if %w[selenium selenium_dev sauce].include? settings.driver
+      if flag
+        page.driver.browser.switch_to.alert.accept
+      else
+        page.driver.browser.switch_to.alert.dismiss
+      end
+    else
+      if flag
+        page.evaluate_script('window.confirm = function() { return true; }')
+      else
+        page.evaluate_script('window.confirm = function() { return false; }')
+      end
+    end
+  end
+
+  ##
+  #
+  # Clicks on button or link using JS event call
+  #
+  # *Parameters:*
+  # * +css_locator+ - Css locator of link or button
+  #
+
+  def js_click(css_locator)
+    page.execute_script("$('#{css_locator}').trigger('click')")
+    sleep settings.timeout_tiny
+  end
+
+  # @deprecated
+  # With Capybara 2.x it is extra
   def wait_for_ajax(timeout=settings.timeout_small, message=nil)
     end_time = ::Time.now + timeout
     until ::Time.now > end_time
-      return if page.evaluate_script('$.active') == 0
+      return true if page.evaluate_script('$.active') == 0
       sleep 0.25
-      log.info "#{Time.now}"
     end
     log.error message || "Timed out waiting for ajax requests to complete"
-
   end
 
-  def wait_for_url(expected_url, time_out=settings.timeout_small)
-    wait_until(time_out) do
+  ##
+  #
+  # Waits until web page is loaded
+  #
+  # *Parameters:*
+  # * +expected_url+ - Url that will be waiting for
+  # * +time_out+ - Seconds that will be waiting for web-site to be loaded until raise error
+  #
+
+  def wait_for_url(expected_url, timeout=settings.timeout_small)
+    end_time = ::Time.now + timeout
+    until ::Time.now > end_time
       operator = expected_url.is_a?(Regexp) ? :=~ : :==
-      current_url.send(operator, expected_url).tap{|res| sleep 1 unless res}
+      return true if current_url.send(operator, expected_url).tap{|res| sleep 1 unless res}
+    end
+    log.error IncorrectPageError, "Current url: #{current_url}, expected:  #{expected_url}"
+  end
+
+  ##
+  #
+  # Waits until web is loaded with expected title
+  #
+  # *Parameters:*
+  # * +expected_title+ - Page title that will be waited for
+  # * +time_out+ - Seconds that will be waiting for web-site to be loaded until raise error
+  #
+
+  def wait_for_title(expected_title, timeout=settings.timeout_small)
+    end_time = ::Time.now + timeout
+    until ::Time.now > end_time
+      operator = expected_title.is_a?(Regexp) ? :=~ : :==
+      return true if title.send(operator, expected_title).tap{|res| sleep 1 unless res}
     end
-  rescue
-    log.error "Current url: #{current_url}, expected:  #{expected_url}"
+    log.error IncorrectPageError, "Current title: #{title}, expected:  #{expected_title}"
   end
 
+  ##
+  #
+  # Reloads current page
+  #
+
   def reload
     log.info "Reload '#{current_url}'"
     visit current_url
   end
 
+  ##
+  #
+  # Returns current url
+  #
+  # *Returns:*
+  # * +string+ - Current url
+  #
+
   def self.current_url
     page.current_url
   end
 
-  def self.text
-    page.find('body').text
+  ##
+  #
+  # Returns Page title
+  #
+  # *Returns:*
+  # * +string+ - Page title
+  #
+
+  def title
+    page.title
   end
 
-  private
-  def initialize
-    wait_for_url(self.class::URL_PATTERN)
+  ##
+  #
+  # Returns body text of html page
+  #
+  # *Returns:*
+  # * +string+ - Body text
+  #
+
+  def self.text
+    page.find('body').text
   end
-end
+end