automation_helpers 4.0

data/lib/automation_helpers/extensions/selenium/webdriver/logs.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Selenium
+  module WebDriver
+    #
+    # Additional useful methods to extend the Selenium::WebDriver::Logs class with
+    #
+    class Logs
+      # @return [Hash]
+      #
+      # Identical to the regular log fetch from Selenium, but stores the logs inside a Hash to be writable later
+      def get(type)
+        cached_logs[type] = @bridge.log(type)
+      end
+
+      # @return [Integer]
+      #
+      # Write the logs to a filepath (If provided), or default file path (Configured). Returns the filesize
+      # as per the regular Ruby Filesystem method
+      def write_log_to_file(type, file = default_file_path)
+        get(type) unless cached_logs.key?(type)
+
+        cached_logs[type].each do |log_entry|
+          if file == $stdout
+            file << log_entry
+          else
+            File.write(file, log_entry)
+          end
+        end
+      end
+
+      private
+
+      def default_file_path
+        AutomationHelpers.chrome_log_path || raise(missing_file_path_error)
+      end
+
+      def cached_logs
+        @cached_logs ||= {}
+      end
+
+      def missing_file_path_error
+        'Set the path to store logs using AutomationHelpers.chrome_log_path= or pass in a filepath directly to #write_log_to_file'
+      end
+    end
+  end
+end

data/lib/automation_helpers/extensions/string.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Additional useful methods to extend the String class with
+class String
+  # @return [String]
+  #
+  # Convert's a regular string name into it's pascalized format
+  # This can then be used to generate a ClassName
+  def pascalize
+    split('_').map(&:capitalize).join
+  end
+
+  # @return [String]
+  #
+  # Convert's a regular string into a snake cased format
+  # Will sanitize out some characters (Designed for titles)
+  def snake_case
+    gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+      .squeeze(' ')
+      .tr('-', '_')
+      .tr(' ', '_')
+      .tr("'", '')
+      .downcase
+  end
+
+  # @return [String]
+  #
+  # Sanitize and convert every individual whitespace character to
+  # a regular space character (Does not sanitize newlines)
+  def sanitize_whitespace
+    gsub(/[ \t\r\f\u00A0]/, ' ')
+  end
+end

data/lib/automation_helpers/extensions.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'automation_helpers/extensions/capybara/node/element'
+require 'automation_helpers/extensions/cucumber/core/test/case'
+require 'automation_helpers/extensions/selenium/webdriver/logs'
+require 'automation_helpers/extensions/array'
+require 'automation_helpers/extensions/string'

data/lib/automation_helpers/logger.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module AutomationHelpers
+  #
+  # @api private
+  #
+  class Logger
+    def self.create(output = $stdout)
+      logger = ::Logger.new(output)
+      logger.progname = 'Automation Helpers'
+      logger.level = :INFO
+      logger.formatter = proc do |severity, time, progname, msg|
+        "#{time.strftime('%F %T')} - #{severity} - #{progname} - #{msg}\n"
+      end
+
+      logger
+    end
+  end
+end

data/lib/automation_helpers/patches/base.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module AutomationHelpers
+  module Patches
+    class Base
+      #
+      # api private (Not intended to be instantiated directly!)
+      #
+      def patch!
+        raise 'This is no longer supported' if prevent_usage?
+
+        Kernel.warn('This is now deprecated and should not be used') if deprecate?
+        AutomationHelpers.logger.info("Adding patch: #{self.class}")
+        AutomationHelpers.logger.debug(description)
+        perform
+        AutomationHelpers.logger.info('Patch successfully added.')
+      end
+
+      private
+
+      #
+      # api private (Not intended to be instantiated directly!)
+      #
+      # From what point should this patch start throwing deprecation notices
+      # If a date is provided, then after that date
+      # If a version from is provided, then all releases after that one (NB: You must provide a link to the gem version)
+      #
+      def deprecate?
+        if defined?(deprecation_notice_date)
+          Time.new >= deprecation_notice_date
+        elsif defined?(deprecate_from)
+          Gem::Version.new(gem_version) >= Gem::Version.new(deprecate_from)
+        end
+      end
+
+      #
+      # api private (Not intended to be instantiated directly!)
+      #
+      # From what point should this patch start preventing usage deprecation notices
+      # If a date is provided, then after that date
+      # If a version from is provided, then all releases after that one (NB: You must provide a link to the gem version)
+      #
+      def prevent_usage?
+        if defined?(prevent_usage_date)
+          Time.new >= prevent_usage_date
+        elsif defined?(prevent_usage_from)
+          Gem::Version.new(gem_version) >= Gem::Version.new(prevent_usage_from)
+        end
+      end
+    end
+  end
+end

data/lib/automation_helpers/patches/capybara.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module AutomationHelpers
+  module Patches
+    class Capybara < Base
+      private
+
+      def description
+        <<~DESCRIPTION
+          There is a bug in the #text method as Safari's w3c conformant endpoint isn't w3c conformant.
+
+          See https://github.com/teamcapybara/capybara/issues/2213 for more details.
+        DESCRIPTION
+      end
+
+      def perform
+        ::Capybara::Node::Element.prepend SafariTextPatch
+      end
+    end
+
+    module SafariTextPatch
+      def text(type = nil, normalize_ws: ::Capybara.default_normalize_ws)
+        super(type, normalize_ws: normalize_ws)
+      end
+    end
+  end
+end

data/lib/automation_helpers/patches/parallel_cucumber.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module AutomationHelpers
+  module Patches
+    class ParallelCucumber < Base
+      private
+
+      def description
+        <<~DESCRIPTION
+          This patch fixes an issue where the parallel tests gem won't place the --retry flag in the correct
+          position for command invocation with cucumber
+          See: https://github.com/grosser/parallel_tests/pull/827 for more details/discussion including this fix
+        DESCRIPTION
+      end
+
+      def perform
+        ::ParallelTests::Gherkin::Runner.extend RetryFlagFix
+      end
+
+      def deprecation_notice_date
+        Time.new(2022, 6, 30)
+      end
+
+      def prevent_usage_from
+        '4.0.0'
+      end
+
+      def gem_version
+        ::ParallelTests::VERSION
+      end
+    end
+
+    module RetryFlagFix
+      def run_tests(test_files, process_number, num_processes, options)
+        # Copied Code - https://github.com/grosser/parallel_tests/blob/master/lib/parallel_tests/gherkin/runner.rb#L9
+        combined_scenarios = test_files
+
+        if options[:group_by] == :scenarios
+          grouped = test_files.map { |t| t.split(':') }.group_by(&:first)
+          combined_scenarios = grouped.map do |file, files_and_lines|
+            "#{file}:#{files_and_lines.map(&:last).join(':')}"
+          end
+        end
+
+        sanitized_test_files = combined_scenarios.map { |val| WINDOWS ? "\"#{val}\"" : Shellwords.escape(val) }
+
+        options[:env] ||= {}
+        options[:env] = options[:env].merge({ 'AUTOTEST' => '1' }) if $stdout.tty?
+
+        # New code
+        opts = cucumber_opts(options[:test_options])
+        cmd = [
+          executable,
+          (runtime_logging if File.directory?(File.dirname(runtime_log))),
+          opts[0],
+          *sanitized_test_files,
+          opts[1]
+        ].compact.reject(&:empty?).join(' ')
+        execute_command(cmd, process_number, num_processes, options)
+      end
+
+      def cucumber_opts(given)
+        # All new code
+        initial =
+          if given =~ (/--profile/) || given =~ (/(^|\s)-p /)
+            given
+          else
+            [given, profile_from_config].compact.join(" ")
+          end
+
+        opts_as_individuals = initial.scan(/\S+\s\S+/)
+        desired_output = ['', '']
+
+        opts_as_individuals.each do |opt|
+          if opt.match?(/--retry \d+/)
+            desired_output[1] = opt
+          else
+            desired_output[0] = "#{desired_output[0]} #{opt}".strip
+          end
+        end
+
+        desired_output
+      end
+    end
+  end
+end

data/lib/automation_helpers/patches/selenium_logger.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module AutomationHelpers
+  module Patches
+    class SeleniumLogger < Base
+      private
+
+      def description
+        <<~DESCRIPTION
+          When using the Selenium Logger that is set to pipe to a file, the Net::HTTP adapter (default),
+          can return unencoded binary (confusingly called ASCII-8BIT in Ruby).
+          Consequently we set the logger to binmode so it doesn't try to encode the data - this would always
+          cause errors for non-ASCII characters, whatever the parent encoding is. An example of this is ©.
+
+          See https://github.com/ruby/net-http/issues/14 for a root cause analysis of the Adapter
+        DESCRIPTION
+      end
+
+      def perform
+        ::Selenium::WebDriver.logger.io.binmode
+      end
+    end
+  end
+end

data/lib/automation_helpers/patches/selenium_manager.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module AutomationHelpers
+  module Patches
+    class SeleniumManager < Base
+      private
+
+      def description
+        <<~DESCRIPTION
+          This patch fixes an issue with Selenium4 not bubbling up the httpOnly property of a cookie
+          See: https://github.com/SeleniumHQ/selenium/pull/8958 for more details/discussion including this fix
+        DESCRIPTION
+      end
+
+      def perform
+        ::Selenium::WebDriver::Manager.prepend CookieConverter
+      end
+
+      def deprecate_from
+        '4.0.0.beta3'
+      end
+
+      def prevent_usage_from
+        '4.0.0.beta5'
+      end
+
+      def gem_version
+        ::Selenium::WebDriver::VERSION
+      end
+    end
+
+    module CookieConverter
+      def convert_cookie(cookie)
+        super(cookie)
+          .merge(
+            {
+              http_only: cookie['httpOnly']
+            }
+          )
+      end
+    end
+  end
+end

data/lib/automation_helpers/patches/selenium_options.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module AutomationHelpers
+  module Patches
+    class SeleniumOptions < Base
+      def initialize(browser)
+        @browser = browser
+        super()
+      end
+
+      # @return [Nil || AutomationHelpers.logger.info]
+      #
+      # For SeleniumOptions we only want to run the patch when
+      # we are on browsers without the relevant JSON fixes in upstream
+      def patch!
+        return unless valid?
+
+        super
+      end
+
+      private
+
+      def valid?
+        %i[firefox safari].include?(@browser)
+      end
+
+      def description
+        <<~DESCRIPTION
+          This patch fixes an issue with Selenium4 not camelising the browser_name property
+          The issue is the driver, which is now fully W3C conformant expects `browserName`
+
+          See: https://github.com/SeleniumHQ/selenium/pull/8834 for more details/discussion including this fix
+          LH - Nov 2020
+        DESCRIPTION
+      end
+
+      def perform
+        case @browser
+        when :firefox then ::Selenium::WebDriver::Firefox::Options.include CapabilitiesAsJsonFix
+        when :safari then ::Selenium::WebDriver::Safari::Options.include CapabilitiesAsJsonFix
+        end
+      end
+
+      def deprecate_from
+        '4.0.0.beta5'
+      end
+
+      def prevent_usage_from
+        '4.0.1'
+      end
+
+      def gem_version
+        ::Selenium::WebDriver::VERSION
+      end
+    end
+
+    module CapabilitiesAsJsonFix
+      private
+
+      def generate_as_json(value, camelize_keys: true)
+        if value.is_a?(Hash)
+          value.each_with_object({}) do |(key, val), hash|
+            key = convert_json_key(key, camelize: camelize_keys)
+            hash[key] = generate_as_json(val, camelize_keys: key != 'prefs')
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/automation_helpers/patches.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'automation_helpers/patches/base'
+require 'automation_helpers/patches/capybara'
+require 'automation_helpers/patches/parallel_cucumber'
+require 'automation_helpers/patches/selenium_logger'
+require 'automation_helpers/patches/selenium_manager'
+require 'automation_helpers/patches/selenium_options'

data/lib/automation_helpers/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AutomationHelpers
+  VERSION = '4.0'
+end

data/lib/automation_helpers.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'automation_helpers/drivers'
+require 'automation_helpers/extensions'
+require 'automation_helpers/logger'
+require 'automation_helpers/patches'
+require 'automation_helpers/version'
+
+# {AutomationHelpers} namespace
+module AutomationHelpers
+  class << self
+    attr_accessor :chrome_log_path
+
+    def configure
+      yield self
+    end
+
+    # The Automation Helpers logger object - This is called automatically in several
+    # locations and will log messages according to the normal Ruby protocol
+    # To alter (or check), the log level; call .log_level= or .log_level
+    #
+    # This logger object can also be used to manually log messages
+    #
+    # To Manually log a message
+    #   AutomationHelpers.logger.info('Information')
+    #   AutomationHelpers.logger.debug('Input debug message')
+    #
+    # By default the logger will output all messages to $stdout, but can be
+    # altered to log to a file or another IO location by calling `.log_path=`
+    def logger
+      @logger ||= Logger.create
+    end
+
+    def logger=(logger)
+      raise ArgumentError, 'You must supply an existing Logger' unless logger.is_a?(::Logger)
+
+      @logger = logger
+    end
+
+    # This writer method allows you to configure where you want the output of
+    # the automation_helpers logs to go (Default is $stdout)
+    #
+    # example: AutomationHelpers.log_path = 'automation_helpers.log' would save all
+    # log messages to `./automation_helpers.log`
+    def log_path=(logdev)
+      logger.reopen(logdev)
+    end
+
+    # To enable full logging (This uses the Ruby API, so can accept any of a
+    # Symbol / String / Integer as an input
+    #   AutomationHelpers.log_level = :DEBUG
+    #   AutomationHelpers.log_level = 'DEBUG'
+    #   AutomationHelpers.log_level = 0
+    #
+    # To disable all logging
+    #   AutomationHelpers.log_level = :UNKNOWN
+    def log_level=(value)
+      logger.level = value
+    end
+
+    # To query what level is being logged
+    #   AutomationHelpers.log_level
+    #   => :INFO # By default
+    def log_level
+      %i[DEBUG INFO WARN ERROR FATAL UNKNOWN][logger.level]
+    end
+  end
+end