seperate methods into different files

.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.DS_Store
+.idea/
+Gemfile.lock
+*.gem

.rubocop.yml

@@ -0,0 +1,40 @@
+AllCops:
+  TargetRubyVersion: 2.5
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/CommentedKeyword:
+  Enabled: false
+
+Style/OptionalBooleanParameter:
+  Enabled: false
+
+Style/RescueStandardError:
+  Enabled: false
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/MethodLength:
+  Max: 100
+
+Metrics/MethodName:
+  Max: 100
+
+Metrics/ClassLength:
+  Max: 250
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Metrics/LineLength:
+  Max: 1000

Gemfile

@@ -5,7 +5,6 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in selenium_webdriver_helper.gemspec
 gemspec
 
-gem 'logger'
-gem 'rake', '~> 13.0'
+gem 'logger_easy'
 gem 'rubocop', '~> 1.21'
 gem 'selenium-webdriver'

LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2022 amit-singh-bisht
+Copyright (c) 2022 Amit Singh Bisht (https://github.com/amit-singh-bisht)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

lib/selenium_webdriver_helper.rb

@@ -23,180 +23,102 @@
 # THE SOFTWARE.
 
 require 'selenium-webdriver'
-require 'logger'
+require_relative 'selenium_webdriver_helper/selenium_webdriver_helper_class'
 require_relative 'selenium_webdriver_helper/constants'
 
 # below is the code to make life easier as it already has selenium webdriver methods defined
 module SeleniumWebdriverHelper
+  def selenium_webdriver_helper(driver, implicit_wait = LONGER_WAIT, log_file_name = 'selenium.log')
+    @driver = driver
+    @implicit_wait = implicit_wait
+    @log_file_name = log_file_name
+    @selenium_webdriver_helper = SeleniumWebdriverHelperClass.new(driver, implicit_wait, log_file_name)
+  end # initialize_selenium_webdriver
+
+  def execute_script(javascript, *args)
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.execute_script(javascript, *args)
+  end # execute_script
+
+  def wait_for_page_load(custom_timeout = LONGER_WAIT)
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.wait_for_page_load(custom_timeout)
+  end # wait_for_page_load
+
+  def get_url(url, driver = @driver)
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.get_url(url, driver)
+  end # get_url
+
+  def maximize_window(driver = @driver)
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.maximize_window(driver)
+  end # maximize_window
+
+  def save_screenshot(path, driver = @driver)
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.save_screenshot(path, driver)
+  end # save_screenshot
+
+  def page_refresh(driver = @driver)
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.page_refresh(driver)
+  end # page_refresh
 
-  class Error < StandardError; end
-
-  attr_accessor :driver
-
-  def log_info(message)
-    logger = Logger.new('selenium.log')
-    logger.info(message)
-  end
-
-  def log_debug(message)
-    logger = Logger.new('selenium.log')
-    logger.debug(message)
-  end
-
-  def log_error(message)
-    logger = Logger.new('selenium.log')
-    logger.error(message)
-  end
-
-  def selectors_from_page_objects(page_object, value = nil)
-    output = []
-    if page_object.is_a?(Array)
-      output << page_object.first
-      output << page_object.last
-    elsif page_object.is_a?(Hash)
-      output = page_object.first
-    elsif value.nil?
-      raise "Locator cannot be nil - #{page_object} #{value}"
-    end
-    output
-  end
-
-  def block_execution(retry_count = 3, &block)
-    block.call
-  rescue Selenium::WebDriver::Error => e
-    logger.info "#{e.message} \n #{e.backtrace}"
-    retry_count -= 1
-    retry if retry_count.positive?
-  end
-
-  def initialize_driver(driver, implicit_wait = LONGER_WAIT)
-    $driver = driver
-    $driver.manage.timeouts.implicit_wait = implicit_wait
-    $wait = Selenium::WebDriver::Wait.new(timeout: implicit_wait) # seconds
-  end
-
-  def execute_script(js, *args)
-    $driver.execute_script(js, *args)
-  rescue Selenium::WebDriver::Error::UnsupportedOperationError => e
-    log_error("[Exception] underlying webdriver instance does not support javascript #{e.message}")
-  end
-
-  def wait_for_page_load(custom_timeout = SHORTER_WAIT)
-    wait = Selenium::WebDriver::Wait.new(timeout: custom_timeout)
-    wait.until { execute_script('return document.readyState;') == 'complete' }
-  end
-
-  def get_url(url, driver = $driver)
-    driver.get(url)
-    # wait_for_page_load
-    log_info("visited #{url}")
-  end
-
-  def maximize_window(driver = $driver)
-    driver.manage.window.maximize
-    log_info('window maximized')
-  end
-
-  def save_screenshot(path, driver = $driver)
-    driver.save_screenshot(path)
-    log_info("screenshot captured and saved at path #{path}")
-  end
-
-  def get_element(selector, custom_timeout = LONGER_WAIT, driver = $driver)
-    how, what = selectors_from_page_objects(selector)
-    block_execution(3) do
-      wait = Selenium::WebDriver::Wait.new(timeout: custom_timeout)
-      begin
-        wait.until { driver.find_element(how, what).displayed? }
-        driver.find_element(how, what)
-      rescue Selenium::WebDriver::Error::NoSuchElementError => e
-        raise "Exception #{e.message} \n #{e.backtrace}"
-      end
-    end
-  end
-
-  def get_elements(selector, custom_timeout = LONGER_WAIT, driver = $driver)
-    how, what = selectors_from_page_objects(selector)
-    block_execution(3) do
-      wait = Selenium::WebDriver::Wait.new(timeout: custom_timeout)
-      begin
-        wait.until { driver.find_elements(how, what)[0].displayed? }
-        driver.find_elements(how, what)
-      rescue Selenium::WebDriver::Error::NoSuchElementError => e
-        raise "Exception #{e.message} \n #{e.backtrace}"
-      end
-    end
-  end
-
-  def element_text(selector, custom_timeout = LONGER_WAIT, driver = $driver)
-    block_execution(3) do
-      get_element(selector, custom_timeout, driver).text
-    end
-  end
-
-  def find_element_and_send_keys(selector, value, driver = $driver)
-    block_execution(3) do
-      get_element(selector).send_keys(value)
-    end
-  end
-
-  def element_click(selector, custom_timeout = LONGER_WAIT, driver = $driver)
-    block_execution(3) do
-      get_element(selector, custom_timeout, driver).click
-    end
-  end
-
-  def element_displayed?(selector)
-    element_list = get_elements(selector)
-    element_list.each do |element|
-      return element if element.displayed?
-    end
-    raise "No visible element found for selector - #{selector}"
-  end
-
-  def wait_for_element_visibility(selector_or_element, visibility = true, custom_timeout = LONG_WAIT)
-    wait = Selenium::WebDriver::Wait.new(timeout: custom_timeout)
-    if !(selector_or_element.is_a?(Array) || selector_or_element.is_a?(Hash))
-      wait.until { selector_or_element.displayed? == visibility }
-    else
-      wait.until { element_displayed?(selector_or_element) == visibility }
-    end
-  end
-
-  def wait_for_element(selector, driver = $driver)
-    how, what = selectors_from_page_objects(selector)
-    5.times do
-      driver.find_element(how, what)
-      break
-    rescue Selenium::WebDriver::Error::NoSuchElementError => e
-      logger.info "[Exception] Retrying to find element due to exception #{e.message}"
-    end
-  end
+  def page_refresh_js
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.page_refresh_js
+  end # get_child_elements
+
+  def get_element(selector, custom_timeout = LONGER_WAIT, driver = @driver)
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.get_element(selector, custom_timeout, driver)
+  end # get_element
+
+  def get_elements(selector, custom_timeout = LONGER_WAIT, driver = @driver)
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.get_elements(selector, custom_timeout, driver)
+  end # get_elements
+
+  def element_text(selector, custom_timeout = LONGER_WAIT, driver = @driver)
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.element_text(selector, custom_timeout, driver)
+  end # element_text
+
+  def find_element_and_send_keys(selector, value, custom_timeout = LONGER_WAIT, driver = @driver)
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.find_element_and_send_keys(selector, value, custom_timeout, driver)
+  end # find_element_and_send_keys
+
+  def element_click(selector, custom_timeout = LONGER_WAIT, driver = @driver)
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.element_click(selector, custom_timeout, driver)
+  end # element_click
+
+  def element_displayed?(selector, custom_timeout = LONGER_WAIT, driver = @driver)
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.element_displayed?(selector, custom_timeout, driver)
+  end # element_displayed?
+
+  def wait_for_element_visibility(selector, visibility = true, custom_timeout = LONG_WAIT, driver = @driver)
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.wait_for_element_visibility(selector, visibility, custom_timeout, driver)
+  end # wait_for_element_visibility
+
+  def wait_for_element(selector, custom_timeout = LONG_WAIT, driver = @driver)
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.wait_for_element(selector, custom_timeout, driver)
+  end # wait_for_element
 
   def get_child_element(parent_element, selector, custom_timeout = LONG_WAIT)
-    how, what = selectors_from_page_objects(selector)
-    block_execution(3) do
-      wait = Selenium::WebDriver::Wait.new(timeout: custom_timeout)
-      wait.until { parent_element.find_element(how, what).displayed? }
-      parent_element.find_element(how, what)
-    end
-  end
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.get_child_element(parent_element, selector, custom_timeout)
+  end # get_child_element
 
   def get_child_elements(parent_element, selector, custom_timeout = LONG_WAIT)
-    how, what = selectors_from_page_objects(selector)
-    block_execution(3) do
-      wait = Selenium::WebDriver::Wait.new(timeout: custom_timeout)
-      wait.until { parent_element.find_elements(how, what)[0].displayed? }
-      parent_element.find_elements(how, what)
-    end
-  end
-
-  def page_refresh(driver = $driver)
-    driver.navigate.refresh
-  end
+    @selenium_webdriver_helper ||= SeleniumWebdriverHelperClass.new(@driver, @implicit_wait, @log_file_name)
+    @selenium_webdriver_helper.get_child_elements(parent_element, selector, custom_timeout)
+  end # get_child_elements
 
-  def page_refresh_js
-    execute_script('location.reload(true);')
-  end
 
-end
+end # SeleniumWebdriverHelper

lib/selenium_webdriver_helper/constants.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 SUPER_ULTRA_SHORT_WAIT = 0.5
 ULTRA_SHORT_WAIT = 1
 SHORTEST_WAIT = 2

lib/selenium_webdriver_helper/methods/alert_methods.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'logger_easy'
+require 'selenium-webdriver'
+require_relative 'common_methods'
+
+# below is the code to make life easier as it already has selenium webdriver methods defined
+module AlertMethods
+
+  include LoggerEasy
+  include CommonMethods
+
+  def accept_alert
+    @browser.switch_to.alert.accept if alert_exist?
+  end
+
+  def dismiss_alert
+    @browser.switch_to.alert.dismiss if alert_exist?
+  end
+
+  def alert_text
+    return @browser.switch_to.alert.text if alert_exist?
+  end
+
+  def alert_exist?
+    @browser.switch_to.alert
+    true
+  rescue Selenium::WebDriver::Error::NoAlertPresentError
+    false
+  rescue Selenium::WebDriver::Error::NoSuchAlertError
+    false
+  rescue Exception => e
+    raise "Error occurred in alert_exist? - #{e}"
+  end
+
+  def wait_for_alert
+    5.times do
+      break if alert_exist?
+
+      sleep SHORTER_WAIT
+    end
+  end
+
+end # AlertMethods