qat-web 6.0.0

data/lib/qat/web/browser/profile.rb

@@ -0,0 +1,92 @@
+require 'capybara'
+require 'qat/logger'
+
+module QAT::Web
+  module Browser
+    # Module to provide browsers specific profile.
+    module Profile
+      include QAT::Logger
+
+      ADDONS = {
+        firefox: {
+          har_exporter: 'harexporttrigger-0.5.0-beta.10.xpi'
+        }
+      }
+
+      def create_profile (driver, browser, properties, addons)
+        return nil unless properties && properties.any?
+        begin
+          method("#{driver}_#{browser}_profile".to_sym).call(properties, addons)
+        rescue NoMethodError => exception
+          if exception.message.match(/.*_.*_profile/)
+            raise(HandlerNotImplemented, "A profile handler for driver '#{driver.capitalize}' and/or '#{browser.capitalize}' does not exist at this moment!")
+          else
+            raise
+          end
+        end
+      end
+
+      private
+      def selenium_firefox_profile(properties, addons)
+        profile = selenium_profile(:firefox, properties)
+
+        profile = load_firefox_addons(profile, addons)
+
+        profile = set_profile(profile, properties)
+
+        { profile: profile }
+      end
+
+      def selenium_chrome_profile (properties, addons)
+        profile = selenium_profile(:chrome, properties)
+
+        profile = set_profile(profile, properties)
+
+        { prefs: profile.send(:prefs) }
+      end
+
+      def selenium_profile(browser, properties)
+        begin
+          require 'selenium-webdriver'
+        rescue LoadError => e
+          if e.message =~ /selenium-webdriver/
+            raise LoadError, "QAT-Web is unable to load `selenium-webdriver`, please install the gem and add `gem 'selenium-webdriver'` to your Gemfile if you are using bundler."
+          else
+            raise e
+          end
+        end
+        Selenium::WebDriver.const_get(browser.capitalize)::Profile.new
+      end
+
+      def set_profile(profile, properties)
+        properties.each { |name, changes| profile[name] = changes }
+        profile
+      end
+
+      def load_firefox_addons(profile, addons)
+
+        addons.each do |addon|
+          path = if File.exist?(addon)
+                   File.realpath(addon)
+                 elsif ADDONS[:firefox][addon.to_sym]
+                   File.expand_path(File.join(File.dirname(__FILE__), "firefox", ADDONS[:firefox][addon.to_sym]))
+                 else
+                   raise(InvalidAddonError, "Addon #{addon} could not be loaded!")
+                 end
+
+          log.debug "Loading Firefox addon from '#{path}'"
+
+          profile.add_extension(path)
+        end if addons&.any?
+
+
+        profile
+      end
+
+      class HandlerNotImplemented < StandardError
+      end
+      class InvalidAddonError < StandardError
+      end
+    end
+  end
+end

data/lib/qat/web/browser/screenshot.rb

@@ -0,0 +1,46 @@
+require_relative '../version'
+require 'capybara'
+require 'qat/logger'
+
+module QAT::Web
+  # Browser namespace
+  module Browser
+    #Module to handle browser screenshots.
+    #@since 1.0.0
+    module Screenshot
+      include QAT::Logger
+      extend self
+
+      #Function to take a browser screenshot. Will handle the usage of driver that don't support screenshots.
+      #@param page [Capybara::Session] Browser to take screenshot from
+      #@param path [String] File path to save screenshot file
+      #@return [String/NilClass]File path to where the screenshot file was saved or nil if the browser doesn't support screenshots
+      #@since 1.0.0
+      def take_screenshot page=Capybara.current_session, path=screenshot_path
+        log.info {"Saving screenshot to #{path}"}
+        raise ArgumentError.new "File #{path} already exists! Choose another filename" if ::File.exists? path
+        path = page.save_screenshot path
+        log.info {"Screenshot available"}
+        path
+      rescue Capybara::NotSupportedByDriverError
+        log.warn {"Driver #{page.mode} does not support screenshots!"}
+        return nil
+      end
+
+      #Default screenshot path. Can be set with {#screenshot_path=}.
+      #@return [String] Screenshot path
+      #@since 1.0.0
+      def screenshot_path
+        @screenshot_path || ::File.join('public', "browser_#{Time.new.strftime("%H%M%S%L")}.png")
+      end
+
+      #Set new default screenshot path.
+      #@param value [String] Screenshot path
+      #@since 1.0.0
+      def screenshot_path= value
+        @screenshot_path = value
+      end
+
+    end
+  end
+end

data/lib/qat/web/configuration.rb

@@ -0,0 +1,46 @@
+require 'capybara'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/hash/keys'
+
+module QAT::Web
+  module Configuration
+    # Parses the configuration value into a usable Capybara selector
+    #@param config [Hash] value from configuration to save
+    #@option config [String] :type Selector type (Capybara.default_selector)
+    #@option config [String] :value Selector value
+    #@see Capybara::Queries::SelectorQuery
+    #@return [Array]
+    def parse_configuration config
+      Configuration.last_access = config
+      @last_access              = config
+      type                      = config.fetch :type, Capybara.default_selector
+      value                     = config.fetch :value
+      opts                      = config.select { |key, _| Capybara::Queries::SelectorQuery::VALID_KEYS.include? key }
+      return type.to_sym, value, opts.to_hash.symbolize_keys
+    end
+
+    # Returns the last value accessed from configuration
+    #@return [Hash]
+    def last_access
+      @last_access
+    end
+
+    class << self
+      # Returns the last value accessed from configuration in all QAT::Web::Configuration instances
+      #@return [Hash]
+      def last_access
+        @last_access
+      end
+
+      # Sets the last value accessed from configuration in all QAT::Web::Configuration instances
+      #@param value [Hash] value from configuration to save
+      #@option value [String] :type Selector type (Capybara.default_selector)
+      #@option value [String] :value Selector value
+      #@see Capybara::Queries::SelectorQuery
+      #@return [Hash]
+      def last_access=(value)
+        @last_access=value
+      end
+    end
+  end
+end

data/lib/qat/web/cucumber.rb

@@ -0,0 +1,19 @@
+require 'capybara/cucumber'
+require_relative '../web'
+require_relative 'hooks/html_dump'
+require_relative 'hooks/screenshot'
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
+
+World QAT::Web::Finders
+
+After do |scenario|
+  if scenario.failed?
+    if QAT::Web::Exceptions::GLOBAL.any? { |exception| scenario.exception.kind_of?(exception) }
+      QAT::Web::Browser.print_url
+    end
+  end
+
+  # Resets the configuration's access registry after each scenario
+  QAT::Web::Configuration.last_access = nil
+end

data/lib/qat/web/drivers.rb

@@ -0,0 +1,3 @@
+require_relative 'drivers/firefox'
+require_relative 'drivers/chrome'
+require_relative 'drivers/default'

data/lib/qat/web/drivers/chrome.rb

@@ -0,0 +1,5 @@
+require 'capybara'
+
+Capybara.register_driver :chrome do |app|
+  Capybara::Selenium::Driver.new(app, browser: :chrome)
+end

data/lib/qat/web/drivers/default.rb

@@ -0,0 +1,25 @@
+module QAT::Web
+  # Drivers namespace
+  module Drivers
+    # Module with drivers default for browsers.
+    module Default
+      extend self
+
+      # Returns the default drivers for browsers
+      #@return [Hash]
+      def mapping
+        setup_defaults unless @defaults
+        @defaults
+      end
+
+      private
+
+      # Initializes the default drivers for browsers
+      #@return [Hash]
+      def setup_defaults
+        @defaults             ||= Hash.new(:selenium)
+        @defaults[:phantomjs] = :poltergeist
+      end
+    end
+  end
+end

data/lib/qat/web/drivers/firefox.rb

@@ -0,0 +1,6 @@
+require 'capybara'
+require_relative 'firefox/har_exporter'
+
+Capybara.register_driver :firefox do |app|
+  Capybara::Selenium::Driver.new(app, browser: :firefox)
+end

data/lib/qat/web/drivers/firefox/har_exporter.rb

@@ -0,0 +1,16 @@
+require 'qat/web/error'
+require 'qat/web/exceptions'
+
+module QAT::Web
+  # Drivers namespace
+  module Drivers
+    # Module with drivers default for browsers.
+    module Firefox
+      class HarExporter
+        TOKEN = 'qat_web_automation'
+
+        EXCEPTIONS = QAT::Web::Exceptions::GLOBAL.dup
+      end
+    end
+  end
+end

data/lib/qat/web/elements.rb

@@ -0,0 +1,78 @@
+require_relative 'elements/selector'
+require_relative 'elements/waiters'
+require_relative 'elements/base'
+require_relative 'elements/element'
+require_relative 'elements/collection'
+
+module QAT
+  module Web
+    # Helper methods to define elements and load configurations.
+    # Auxiliary methods for the elements are also defined here.
+    module Elements
+      include Selector
+      include Waiters
+
+      # Loads a configuration file
+      # @param file_path [String] configuration file path
+      # @return [Hash]
+      def load_elements_file(file_path)
+        begin
+          config = YAML::load(ERB.new(File.read(file_path)).result)
+        rescue Psych::SyntaxError
+          log.error "Failed to load file '#{file_path}'."
+          raise
+        end
+        config
+      end
+
+      private
+      # Defines all dynamic web elements methods
+      # @param web_element [Element|Collection] web element configuration
+      def define_web_element_methods(web_element)
+        define_method(web_element.name) { web_element.finder.call }
+        define_selectors(web_element)
+        define_config_accessor(web_element)
+        define_waiters(web_element)
+      end
+
+      # Defines the configuration accessor for the web elements
+      # @param web_element [Element] web element object
+      def define_config_accessor(web_element)
+        define_method "config_#{web_element.name}" do
+          web_element.config
+        end
+      end
+
+      # Defines the selector accessor for the web elements
+      # @param web_element [Element] web element object
+      def define_selectors(web_element)
+        define_method "selector_#{web_element.name}" do
+          web_element.selector
+        end
+      end
+
+      # Defines the waiting methods for the web elements
+      # @param web_element [Element] web element object
+      def define_waiters(web_element)
+        selector = web_element.selector
+        name     = web_element.name
+
+        define_method "wait_until_#{name}_visible" do |timeout|
+          wait_until_visible(selector, timeout)
+        end
+
+        define_method "wait_until_#{name}_present" do |timeout|
+          wait_until_present(selector, timeout)
+        end
+
+        define_method "wait_while_#{name}_visible" do |timeout|
+          wait_until_not_visible(selector, timeout)
+        end
+
+        define_method "wait_while_#{name}_present" do |timeout|
+          wait_until_not_present(selector, timeout)
+        end
+      end
+    end
+  end
+end

data/lib/qat/web/elements/base.rb

@@ -0,0 +1,50 @@
+require 'capybara/dsl'
+require_relative 'selector'
+require_relative 'config'
+
+module QAT
+  module Web
+    module Elements
+      # Web Element wrapper base class
+      class Base
+        include Capybara::DSL
+        include QAT::Logger
+        include Selector
+        include Config
+
+        attr_reader :name, :config, :selector
+
+        # New instance
+        # @param elements [Hash] Page Object related elements configuration
+        # @param args [Array] One or two arguments are expected. The first argument is the element *name*
+        # and the second an optional *configuration*.
+        # If none is given, it will be automatically loaded from the loaded configuration by the element name
+        def initialize(elements, *args)
+          get_element_info(elements, *args)
+          @selector = extract_selector(@config)
+        end
+
+        private
+        # Parsed the configuration information for element or collection of elements
+        # @param args [Array] One or two arguments are expected. The first argument is the element *name*
+        # and the second an optional *configuration*.
+        # If none is given, it will be automatically loaded from the loaded configuration by the element name
+        # @raise ArgumentError if more than two arguments are given.
+        # @raise ArgumentError if a nil configuration is given.
+        # @raise ArgumentError if no configuration is found in cache.
+        # @return [Array]
+        def get_element_info(elements, *args)
+          raise ArgumentError.new "Wrong number of arguments! Expecting [name, configuration]!" if args.size > 2
+
+          @name, @config = args
+          raise ArgumentError.new "Configuration given for element '#{@name}' is nil!" if args.size == 2 && @config.nil?
+
+          @config ||= elements[:locators][@name]
+          raise ArgumentError.new "No configuration found for web element '#{@name}', please check definition" if @config.nil? or (@config.is_a? Hash and @config.empty?)
+
+          [@name, @config]
+        end
+      end
+    end
+  end
+end

data/lib/qat/web/elements/collection.rb

@@ -0,0 +1,16 @@
+require_relative 'base'
+
+module QAT
+  module Web
+    module Elements
+      # Web Element wrapper class for web elements collection
+      class Collection < Base
+        # Returns the collection finder block
+        # @return [Proc]
+        def finder
+          proc { all(*@selector) }
+        end
+      end
+    end
+  end
+end

data/lib/qat/web/elements/config.rb

@@ -0,0 +1,19 @@
+module QAT
+  module Web
+    module Elements
+      # Configuration handling helper
+      module Config
+        # Validates that the given config is in the correct format
+        # @param config [Hash] configuration hash
+        # @param collection [String] collection name
+        # @return [Boolean]
+        def valid_config?(config, collection)
+          unless config.kind_of?(Hash) && config.any?
+            raise(ArgumentError, "Empty or invalid configuration was given for #{collection.capitalize}! A hash like configuration is expected!")
+          end
+          true
+        end
+      end
+    end
+  end
+end

data/lib/qat/web/elements/element.rb

@@ -0,0 +1,16 @@
+require_relative 'base'
+
+module QAT
+  module Web
+    module Elements
+      # Web Element wrapper class for a web element
+      class Element < Base
+        # Returns the element finder block
+        # @return [Proc]
+        def finder
+          proc { find(*@selector) }
+        end
+      end
+    end
+  end
+end