From 0a04d989c0b92c91c9e97706306b9a82a2f43788 Mon Sep 17 00:00:00 2001 From: amitsingh-bisht Date: Sun, 20 Nov 2022 19:45:43 +0530 Subject: [PATCH] seperate methods into different files --- .gitignore | 12 + .rubocop.yml | 40 +++ Gemfile | 3 +- LICENSE.txt | 2 +- Rakefile | 8 - lib/selenium_webdriver_helper.rb | 254 ++++++------------ lib/selenium_webdriver_helper/constants.rb | 2 + .../methods/alert_methods.rb | 44 +++ .../methods/checkbox_methods.rb | 28 ++ .../methods/common_methods.rb | 38 +++ .../methods/cookie_methods.rb | 45 ++++ .../methods/devtools.rb | 27 ++ .../methods/element(s)_methods.rb | 48 ++++ .../methods/element_attribute_methods.rb | 32 +++ .../methods/element_methods.rb | 168 ++++++++++++ .../methods/file_methods.rb | 14 + .../methods/iframe_methods.rb | 31 +++ .../methods/javascript_methods.rb | 52 ++++ .../methods/keyboards.rb | 90 +++++++ .../methods/mouse_methods.rb | 47 ++++ .../methods/page_methods.rb | 67 +++++ .../methods/parent_methods.rb | 24 ++ .../methods/screenshot_methods.rb | 24 ++ .../methods/tab_methods.rb | 34 +++ .../methods/url_methods.rb | 49 ++++ .../methods/window_methods.rb | 60 +++++ .../selenium_webdriver_helper_class.rb | 23 ++ selenium_webdriver_helper.gemspec | 30 +-- 28 files changed, 1104 insertions(+), 192 deletions(-) create mode 100644 .gitignore create mode 100644 .rubocop.yml delete mode 100644 Rakefile create mode 100644 lib/selenium_webdriver_helper/methods/alert_methods.rb create mode 100644 lib/selenium_webdriver_helper/methods/checkbox_methods.rb create mode 100644 lib/selenium_webdriver_helper/methods/common_methods.rb create mode 100644 lib/selenium_webdriver_helper/methods/cookie_methods.rb create mode 100644 lib/selenium_webdriver_helper/methods/devtools.rb create mode 100644 lib/selenium_webdriver_helper/methods/element(s)_methods.rb create mode 100644 lib/selenium_webdriver_helper/methods/element_attribute_methods.rb create mode 100644 lib/selenium_webdriver_helper/methods/element_methods.rb create mode 100644 lib/selenium_webdriver_helper/methods/file_methods.rb create mode 100644 lib/selenium_webdriver_helper/methods/iframe_methods.rb create mode 100644 lib/selenium_webdriver_helper/methods/javascript_methods.rb create mode 100644 lib/selenium_webdriver_helper/methods/keyboards.rb create mode 100644 lib/selenium_webdriver_helper/methods/mouse_methods.rb create mode 100644 lib/selenium_webdriver_helper/methods/page_methods.rb create mode 100644 lib/selenium_webdriver_helper/methods/parent_methods.rb create mode 100644 lib/selenium_webdriver_helper/methods/screenshot_methods.rb create mode 100644 lib/selenium_webdriver_helper/methods/tab_methods.rb create mode 100644 lib/selenium_webdriver_helper/methods/url_methods.rb create mode 100644 lib/selenium_webdriver_helper/methods/window_methods.rb create mode 100644 lib/selenium_webdriver_helper/selenium_webdriver_helper_class.rb diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..f84fe11 --- /dev/null +++ b/.gitignore @@ -0,0 +1,12 @@ +/.bundle/ +/.yardoc +/_yardoc/ +/coverage/ +/doc/ +/pkg/ +/spec/reports/ +/tmp/ +.DS_Store +.idea/ +Gemfile.lock +*.gem diff --git a/.rubocop.yml b/.rubocop.yml new file mode 100644 index 0000000..4101503 --- /dev/null +++ b/.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 diff --git a/Gemfile b/Gemfile index 0572237..d0e1233 100644 --- a/Gemfile +++ b/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' diff --git a/LICENSE.txt b/LICENSE.txt index d52b420..485dcc0 100644 --- a/LICENSE.txt +++ b/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 diff --git a/Rakefile b/Rakefile deleted file mode 100644 index 1924143..0000000 --- a/Rakefile +++ /dev/null @@ -1,8 +0,0 @@ -# frozen_string_literal: true - -require "bundler/gem_tasks" -require "rubocop/rake_task" - -RuboCop::RakeTask.new - -task default: :rubocop diff --git a/lib/selenium_webdriver_helper.rb b/lib/selenium_webdriver_helper.rb index 986ac29..79c4b2f 100644 --- a/lib/selenium_webdriver_helper.rb +++ b/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 diff --git a/lib/selenium_webdriver_helper/constants.rb b/lib/selenium_webdriver_helper/constants.rb index ba6153e..6ce099e 100644 --- a/lib/selenium_webdriver_helper/constants.rb +++ b/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 diff --git a/lib/selenium_webdriver_helper/methods/alert_methods.rb b/lib/selenium_webdriver_helper/methods/alert_methods.rb new file mode 100644 index 0000000..46c63ae --- /dev/null +++ b/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 diff --git a/lib/selenium_webdriver_helper/methods/checkbox_methods.rb b/lib/selenium_webdriver_helper/methods/checkbox_methods.rb new file mode 100644 index 0000000..ca1448d --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/checkbox_methods.rb @@ -0,0 +1,28 @@ +# 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 CheckboxMethods + + include LoggerEasy + include CommonMethods + + def checkbox_selected?(element) + element.selected? + end + + def click_checkbox(selector) + checkbox = get_element(selector) + element_click(checkbox) + end + + def uncheck_checkbox(element) + if checkbox_selected?(element) + element_click(element) + end + end + +end # CheckboxMethods diff --git a/lib/selenium_webdriver_helper/methods/common_methods.rb b/lib/selenium_webdriver_helper/methods/common_methods.rb new file mode 100644 index 0000000..4b7c81b --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/common_methods.rb @@ -0,0 +1,38 @@ +# frozen_string_literal: true + +require 'logger_easy' +require 'selenium-webdriver' + +# below is the code to make life easier as it already has common selenium webdriver methods defined +module CommonMethods + + include LoggerEasy + + def block_execution(retry_count = 3, &block) + block.call + rescue => e + retry_count -= 1 + retry if retry_count.positive? + log_error "[selenium webdriver helper] ERROR : #{e.inspect} - #{e.message}\n#{e.backtrace}" + raise "[selenium webdriver helper] ERROR : #{e.inspect} - #{e.message}\n#{e.backtrace}" + end # block_execution + + def selectors_from_page_objects(page_object, value = nil) + block_execution(1) do + 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 "[selenium webdriver helper] Locator cannot be nil - #{page_object} #{value}" if value.nil? + + output << page_object + output << value + end # if-else condition + log_info "[selenium webdriver helper] how, what: #{output}" + output + end # block_execution + end # selectors_from_page_objects +end # CommonMethods diff --git a/lib/selenium_webdriver_helper/methods/cookie_methods.rb b/lib/selenium_webdriver_helper/methods/cookie_methods.rb new file mode 100644 index 0000000..f480749 --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/cookie_methods.rb @@ -0,0 +1,45 @@ +# 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 CookieMethods + + include LoggerEasy + include CommonMethods + + def add_cookie(name, value, opts = {}) + cookie = { + name: name, + value: value + } + cookie[:secure] = opts[:secure] if opts[:secure] + cookie[:path] = opts[:path] if opts[:path] + cookie[:expires] = opts[:expires] if opts[:expires] + cookie[:domain] = opts[:domain] if opts[:domain] + @browser.manage.add_cookie cookie + end + + def delete_all_cookies + @browser.manage.delete_all_cookies + end + + def cookie_data(cookie_name = nil) + value = nil + @browser.manage.all_cookies.each do |cookie| + value = cookie[:value] if cookie_name.include? cookie[:name].to_s + end + value + end + + def set_cookie_value(cookie_name, cookie_value) + raise 'Cookie Not Found' if cookie_data(cookie_name).nil? + + @browser.manage.delete_cookie(cookie_name) + add_cookie(cookie_name, cookie_value) # Add as third argument for local as { domain: 'bsstag.com' }) + page_refresh + raise 'Cookie is not changed for given experiment' unless cookie_data(cookie_name).eql?(cookie_value) + end +end # CookieMethods diff --git a/lib/selenium_webdriver_helper/methods/devtools.rb b/lib/selenium_webdriver_helper/methods/devtools.rb new file mode 100644 index 0000000..5073f58 --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/devtools.rb @@ -0,0 +1,27 @@ +# 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 DevToolsMethods + + include LoggerEasy + include CommonMethods + + def send_devtools_cmd(driver, cmd, params = {}) + bridge = driver.send(:bridge) + resource = "session/#{bridge.session_id}/chromium/send_command_and_get_result" + response = bridge.http.call(:post, resource, { 'cmd': cmd, 'params': params }) + raise response[:value] if response[:status] + + logger.info("send_devtools_cmd - #{cmd} -#{response[:value]}") + response[:value] + end + + def throttle_network(network_conditions) + send_devtools_cmd(@browser, 'Network.emulateNetworkConditions', network_conditions) + end + +end # DevToolsMethods diff --git a/lib/selenium_webdriver_helper/methods/element(s)_methods.rb b/lib/selenium_webdriver_helper/methods/element(s)_methods.rb new file mode 100644 index 0000000..8555cd2 --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/element(s)_methods.rb @@ -0,0 +1,48 @@ +# 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 ElementsMethods + + include LoggerEasy + include CommonMethods + + def get_elements(selector, custom_timeout, driver) + block_execution do + how, what = selectors_from_page_objects(selector) + wait = Selenium::WebDriver::Wait.new(timeout: custom_timeout) + wait.until { driver.find_elements(how, what)[0].displayed? } + log_info "[selenium webdriver helper] multiple element(s) #{what} using #{how} was displayed within custom time #{custom_timeout} seconds." + driver.find_elements(how, what) + end # block_execution + end # get_elements + + def number_of_elements_displayed(selector, custom_timeout, driver) + block_execution do + elements = get_elements(selector, custom_timeout, driver) + log_info "[selenium webdriver helper] was able to find multiple element(s) #{@what} using #{@how} within custom time #{custom_timeout} seconds." + elements.length + end # block_execution + end + + def get_child_elements(parent_element, selector, custom_timeout) + block_execution do + how, what = selectors_from_page_objects(selector) + 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 # block_execution + end # get_child_elements + + def get_elements_text_list(selector, custom_timeout, driver) + element_list = get_elements(selector, custom_timeout, driver) + element_text_list = [] + element_list.each_with_index { |_element,index| + element_text_list[index] = element_list[index].text.strip + } + element_text_list + end +end diff --git a/lib/selenium_webdriver_helper/methods/element_attribute_methods.rb b/lib/selenium_webdriver_helper/methods/element_attribute_methods.rb new file mode 100644 index 0000000..019a25f --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/element_attribute_methods.rb @@ -0,0 +1,32 @@ +# 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 ElementAttributeMethods + + include LoggerEasy + include CommonMethods + + def element_attribute(element_or_selector, attribute) + element = if !(element_or_selector.is_a?(Array) || element_or_selector.is_a?(Hash)) + element_or_selector + else + block_execution(3) do + get_element(element_or_selector, false) + end + end + element.attribute(attribute) + end + + def set_element_attribute(element, attribute_name, attribute_value) + execute_script("arguments[0].setAttribute('#{attribute_name}', '#{attribute_value}')",element) + end + + def element_style(element, style) + element.style(style) + end + +end # ElementAttributeMethods diff --git a/lib/selenium_webdriver_helper/methods/element_methods.rb b/lib/selenium_webdriver_helper/methods/element_methods.rb new file mode 100644 index 0000000..aceeb74 --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/element_methods.rb @@ -0,0 +1,168 @@ +# 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 ElementMethods + + include LoggerEasy + include CommonMethods + + def get_element(selector, custom_timeout, driver) + block_execution do + @how, @what = selectors_from_page_objects(selector) + wait = Selenium::WebDriver::Wait.new(timeout: custom_timeout) + wait.until { driver.find_element(@how, @what).displayed? } + log_info "[selenium webdriver helper] element #{@what} using #{@how} was displayed within custom time #{custom_timeout} seconds." + driver.find_element(@how, @what) + end # block_execution + end # get_element + + def element_text(selector, custom_timeout, driver) + block_execution do + element = get_element(selector, custom_timeout, driver) + log_info "[selenium webdriver helper] was able to find element #{@what} using #{@how} within custom time #{custom_timeout} seconds." + element.text + end # block_execution + end # element_text + + def find_element_and_send_keys(selector, value, custom_timeout, driver) + block_execution do + element = get_element(selector, custom_timeout, driver) + log_info "[selenium webdriver helper] was able to find element #{@what} using #{@how} within custom time #{custom_timeout} seconds." + element.send_keys(value) + end # block_execution + end # find_element_and_send_keys + + def element_click(selector, custom_timeout, driver) + block_execution do + element = get_element(selector, custom_timeout, driver) + log_info "[selenium webdriver helper] was able to find element #{@what} using #{@how} within custom time #{custom_timeout} seconds." + element.click + end # block_execution + end # element_click + + def element_click_js(selector, custom_timeout, driver) + block_execution do + if selector.instance_of?(Selenium::WebDriver::Element) + execute_script('return arguments[0].click()', selector) + elsif selector.instance_of?(String) + execute_script("$(\"#{selector}\").click()") + else + element_click(selector, custom_timeout, driver) + end + end + end + + def element_displayed?(selector, custom_timeout, driver) + block_execution do + elements = get_elements(selector, custom_timeout, driver) + log_info "[selenium webdriver helper] was able to find multiple element(s) #{@what} using #{@how} within custom time #{custom_timeout} seconds." + elements.length.zero ? false : true + end # block_execution + end # element_displayed? + + def element_displayed_js?(selector) + block_execution do + case selector + when Array + _how, what = selectors_from_page_objects(selector) + when String + what = selector + end + execute_script("return $(\"#{what}\").is(\":visible\")") + end + end + + def element_not_displayed_condition(using, locator) + !@driver.find_element(using, locator).displayed? + rescue Selenium::WebDriver::Error::NoSuchElementError + true + end + + def element_not_displayed?(selector, check_wait = true, custom_timeout = SHORTEST_WAIT) + block_execution do + how, what = selectors_from_page_objects(selector) + if check_wait + begin + wait = Selenium::WebDriver::Wait.new(timeout: custom_timeout) + wait.until { element_not_displayed_condition(how, what) } + rescue StandardError => e + logger.info "Exception thrown for #{what} : #{e}" + false + end + else + element_not_displayed_condition(how, what) + end + end + end + + def wait_for_element_visibility(selector, visibility, custom_timeout, driver) + block_execution do + wait = Selenium::WebDriver::Wait.new(timeout: custom_timeout) + wait.until { element_displayed?(selector, custom_timeout, driver) == visibility } + end # block_execution + end # wait_for_element_visibility + + def wait_for_element(selector, custom_timeout, driver) + block_execution do + how, what = selectors_from_page_objects(selector) + wait = Selenium::WebDriver::Wait.new(timeout: custom_timeout) + wait.until { driver.find_element(how, what) } + end # block_execution + end # wait_for_element + + def get_child_element(parent_element, selector, custom_timeout) + block_execution do + how, what = selectors_from_page_objects(selector) + wait = Selenium::WebDriver::Wait.new(timeout: custom_timeout) + wait.until { parent_element.find_element(how, what).displayed? } + parent_element.find_element(how, what) + end # block_execution + end # get_child_element + + def get_element_location(element) + element.location + end + + def element_value(selector_or_element) + element_attribute(selector_or_element, 'value') + end + + def element_from_element_or_selector(selector, custom_timeout, driver) + if !(selector.is_a?(Array) || selector.is_a?(Hash)) + selector + else + get_element(selector, custom_timeout, driver) + end + end + + def get_element_height_and_width(element) + height = element_attribute(element, 'height').to_i + width = element_attribute(element, 'width').to_i + [height, width] + end + + def element_disabled?(element) + element_attribute(element, 'class').include?('disabled') || element_attribute(element, 'disabled') == 'true' + end + + def click_element_and_select_value(selector, custom_timeout, driver, dropdown_value_selector) + element = get_element(selector, custom_timeout, driver) + element.click + sleep SHORTEST_WAIT + element = get_element(dropdown_value_selector, custom_timeout, driver) + element.click + end + + def element_in_view?(selector) + case selector[0] + when :id + execute_script("return isElementInView(document.getElementById('#{selector[0]}'))") + when :css + execute_script("return isElementInView(document.querySelector('#{selector[1]}'))") + end + end +end diff --git a/lib/selenium_webdriver_helper/methods/file_methods.rb b/lib/selenium_webdriver_helper/methods/file_methods.rb new file mode 100644 index 0000000..347cbfb --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/file_methods.rb @@ -0,0 +1,14 @@ +# 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 FileMethods + + include LoggerEasy + include CommonMethods + + +end # FileMethods diff --git a/lib/selenium_webdriver_helper/methods/iframe_methods.rb b/lib/selenium_webdriver_helper/methods/iframe_methods.rb new file mode 100644 index 0000000..76a9e4c --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/iframe_methods.rb @@ -0,0 +1,31 @@ +# 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 IFrameMethods + + include LoggerEasy + include CommonMethods + + def switch_frame(frame_id, retry_count = 5) + i = 0 + while i < retry_count + begin + @browser.switch_to.frame(frame_id) + break + rescue Exception => e + logger.info e.message + sleep SHORT_WAIT + i += 1 + end + end + end + + def switch_to_default + @browser.switch_to.default_content + end + +end # IFrameMethods diff --git a/lib/selenium_webdriver_helper/methods/javascript_methods.rb b/lib/selenium_webdriver_helper/methods/javascript_methods.rb new file mode 100644 index 0000000..fbb08f6 --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/javascript_methods.rb @@ -0,0 +1,52 @@ +# 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 JavascriptMethods + + include LoggerEasy + include CommonMethods + + def execute_script(javascript, *args) + block_execution do + @driver.execute_script(javascript, *args) + log_info "[selenium webdriver helper] executed script: #{javascript} successfully." + end # block_execution + end # execute_script + + def window_scroll_x + execute_script('return window.scrollX') + end + + def window_scroll_y + execute_script('return window.scrollY') + end + + def scroll_to(selector, x_coordinate = 0, y_coordinate = 0) + element = get_element(selector) + @browser.execute_script("arguments[0].scrollTo(#{x_coordinate},#{y_coordinate});", element) + end + + def scroll_to_top + wait_for_page_load + @browser.execute_script('$(document).scrollTop(0);') + end + + def page_scroll_down(count = 2, x = 0, y = 600) + count.times do + @browser.execute_script("window.scrollBy(#{x},#{y})", '') + sleep SHORTEST_WAIT + end + end + + def console_logs + @browser.manage.logs.get(:browser) + end + + def location_hash + @browser.execute_script('return window.location.hash') + end +end diff --git a/lib/selenium_webdriver_helper/methods/keyboards.rb b/lib/selenium_webdriver_helper/methods/keyboards.rb new file mode 100644 index 0000000..7eff2c0 --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/keyboards.rb @@ -0,0 +1,90 @@ +# 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 KeyboardsMethods + + include LoggerEasy + include CommonMethods + + def press_keys(keys, element = nil) + begin + if element.nil? + keys.split("").each do |key| + @browser.action.send_keys(key).perform + sleep SUPER_ULTRA_SHORT_WAIT + end + else + @browser.action.send_keys(element, key).perform + end + rescue Exception => e + @browser.action.send_keys(keys).perform + sleep SHORT_WAIT + end + end + + def select_all_using_keyboard(key = :control) + key_down(key) + press_keys('a') + key_up(key) + end + + def paste_using_keyboard(key = :control) + key_down(key) + press_keys('v') + key_up(key) + end + + def key_up(key) + @browser.action.key_up(key.to_sym).perform + end + + def key_down(key) + @browser.action.key_down(key.to_sym).perform + end + + def clear_text_field(element_or_selector, clear = true) + element = element_from_element_or_selector(element_or_selector) + element.clear if clear + element + end + + def send_keys(element_or_selector, value, clear = true) + element = clear_text_field element_or_selector, clear + element.send_keys(value) + end + + def send_keys_js(element, value, clear = true) + element.clear if clear + execute_script("arguments[0].value = '#{value}'", element) + end + + def select_from_dropdown(selector, select_by, option) + drop_down_menu = get_element(selector) + options = Selenium::WebDriver::Support::Select.new(drop_down_menu) + options.select_by(select_by, option) + end + + def scroll_up_till_element_visible(using) + 5.times do + scroll_up unless element_displayed?(using) + end + end + + def scroll_up + 5.times do + press_keys(:arrow_up) + end + end + + def send_keys_for_ie(selector, value) + if selector[0].eql?(:id) + execute_script("document.getElementById('#{selector[1]}').value = '#{value}'") + elsif selector[0].eql?(:css) + execute_script("document.querySelector('#{selector[1]}').value = '#{value}'") + end + end +end # KeyboardsMethods diff --git a/lib/selenium_webdriver_helper/methods/mouse_methods.rb b/lib/selenium_webdriver_helper/methods/mouse_methods.rb new file mode 100644 index 0000000..fb10c2b --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/mouse_methods.rb @@ -0,0 +1,47 @@ +# 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 MouseMethods + + include LoggerEasy + include CommonMethods + + def hover_to_element(element) + @browser.action.move_to(element).perform + end + + def move_to_element_and_click(element, x_coordinate = 0, y_coordinate = 0) + @browser.action.move_to(element, x_coordinate, y_coordinate).click.perform + end + + def move_by_and_click(x_coordinate = 0, y_coordinate = 0) + @browser.action.move_by(x_coordinate, y_coordinate).click.perform + end + + def move_by_and_scroll(selector, x_coordinate = 100, y_coordinate = 100, custom_timeout = nil) + wait = Selenium::WebDriver::Wait.new(timeout: (custom_timeout.nil? ? LONGER_WAIT : custom_timeout)) + driver_temp = @browser + element1 = wait.until { driver_temp.find_element(selector[0], selector[1]) } + @browser.action.click_and_hold(element1).move_by(x_coordinate, y_coordinate).release.perform + end + + def scroll_to_element_and_click(selector_or_element, x_coordinate = 0, y_coordinate = 300) + 10.times do + element = selector_or_element.instance_of?(Selenium::WebDriver::Element) ? selector_or_element : get_element(selector_or_element) + begin + element.click + break + rescue + page_scroll_down(1, x_coordinate, y_coordinate) + end + end + end + + def element_drag_and_drop_by(element, x_offset = 100, y_offset = 100) + @browser.action.drag_and_drop_by(element, x_offset, y_offset).perform + end +end # MouseMethods diff --git a/lib/selenium_webdriver_helper/methods/page_methods.rb b/lib/selenium_webdriver_helper/methods/page_methods.rb new file mode 100644 index 0000000..c1f60dc --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/page_methods.rb @@ -0,0 +1,67 @@ +# 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 PageMethods + + include LoggerEasy + include CommonMethods + + def wait_for_page_load(custom_timeout) + block_execution do + wait = Selenium::WebDriver::Wait.new(timeout: custom_timeout) + wait.until { execute_script('return document.readyState;') == 'complete' } + log_info "[selenium webdriver helper] page is loaded successfully i.e. document.readyState == 'complete'" + end # block_execution + end # wait_for_page_load + + def page_refresh(driver) + driver.navigate.refresh + end # page_refresh + + def page_refresh_js + execute_script('location.reload(true);') + end # page_refresh_js + + def page_title + @browser.title + end + + def page_url_scheme_https? + current_page_url.include?('https') + end + + def page_loaded?(url_path, retry_count = 5) + count = 0 + while count < retry_count + count += 1 + current_url = current_page_url + state = execute_script('return document.readyState').eql?('complete') + return true if state && !current_url.nil? && current_url.to_s.include?(url_path) + + sleep SHORTEST_WAIT + end + false + end + + def wait_for_element_with_page_refresh(selector, visibility = true, retry_count = 3, wait_time = SHORT_WAIT) + count = 0 + while count < retry_count + count += 1 + page_refresh(driver) + return true if element_displayed?(selector, true, wait_time) == visibility + end + raise "element visibility is not #{visibility} for #{selector}" unless element_displayed?(selector, true, wait_time) == visibility + end + + def navigate_to_previous_page + @browser.navigate.back + end + + def hard_page_refresh + @browser.execute_script('location.reload(true);') + end +end diff --git a/lib/selenium_webdriver_helper/methods/parent_methods.rb b/lib/selenium_webdriver_helper/methods/parent_methods.rb new file mode 100644 index 0000000..72ad556 --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/parent_methods.rb @@ -0,0 +1,24 @@ +# 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 ParentMethods + + include LoggerEasy + include CommonMethods + + def get_parent_element_xpath(selector) + how, what = selectors_from_page_objects(selector) + selector = [:xpath, "#{what}/.."] if (how.eql? :xpath) || (how.eql? 'xpath') + log_info "[selenium webdriver helper] parent element of #{what} is #{selector.last}" + selector + end + + def get_grandparent_element_xpath(selector) + get_parent_element_xpath(get_parent_element_xpath(selector)) + end + +end diff --git a/lib/selenium_webdriver_helper/methods/screenshot_methods.rb b/lib/selenium_webdriver_helper/methods/screenshot_methods.rb new file mode 100644 index 0000000..b158766 --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/screenshot_methods.rb @@ -0,0 +1,24 @@ +# 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 ScreenshotMethods + + include LoggerEasy + include CommonMethods + + def save_screenshot(path, driver) + block_execution do + driver.save_screenshot(path) + log_info "[selenium webdriver helper] screenshot captured and saved at path #{path}." + end # block_execution + end # save_screenshot + + def get_image_natural_width(img_element) + execute_script('return arguments[0].naturalWidth', img_element) + end + +end diff --git a/lib/selenium_webdriver_helper/methods/tab_methods.rb b/lib/selenium_webdriver_helper/methods/tab_methods.rb new file mode 100644 index 0000000..d4b0d83 --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/tab_methods.rb @@ -0,0 +1,34 @@ +# 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 TabMethods + + include LoggerEasy + include CommonMethods + + def visit_url_in_new_tab(url) + new_tab + @browser.navigate.to url + end + + def new_tab(action = 'open') ## If users wants to close tab, give "close" in argument instead of "open" + @browser.execute_script("window.#{action}()") + retry_count = 2 + begin + switch_to_window(@browser.window_handles.last) + rescue + logger.info '[Window Handles]' + retry_count -= 1 + retry if retry_count.positive? + switch_to_window(@browser.window_handles.first) + end + end + + def open_link_in_new_tab(key,element) + @browser.action.move_to(element).key_down(key.to_sym).click.perform + end +end # TabMethods diff --git a/lib/selenium_webdriver_helper/methods/url_methods.rb b/lib/selenium_webdriver_helper/methods/url_methods.rb new file mode 100644 index 0000000..695dfe1 --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/url_methods.rb @@ -0,0 +1,49 @@ +# 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 URLMethods + + include LoggerEasy + include CommonMethods + + def get_url(url, driver) + block_execution do + driver.get(url) + log_info "[selenium webdriver helper] visited #{url} successfully." + end # block_execution + end # get_url + + def current_page_url + @browser.current_url + end + + def visit_url(url, driver2 = nil) + if driver2.nil? + # (env_variable('CURRENT_BROWSER').include? "chrome") ? @browser.navigate.to(url) : visit_url_using_js(url, @browser) + 'abed' + else + 'length' + # (env_variable('CURRENT_BROWSER').include? "chrome") ? driver2.navigate.to(url) : visit_url_using_js(url, driver2) + end + #### Need to fix the following code for getting browser console logs, getting exceptions at various places. + # logs = (env_variable('CURRENT_BROWSER').include? "chrome")? (@browser.manage.logs.get :browser) : [] + # unless logs.empty? + # url_logs = [] + # logs.each do |log_entry| + # log_entry = log_entry.as_json + # url_logs << [log_entry['level'], log_entry['message']].join(' ') + # end + # @browser_console_logs[url] = url_logs + # end + end + + def visit_url_using_js(url, driver) + driver.execute_script("location.href='#{url}';") + sleep SHORT_WAIT if env_variable('CURRENT_BROWSER').include?('firefox') + end + +end diff --git a/lib/selenium_webdriver_helper/methods/window_methods.rb b/lib/selenium_webdriver_helper/methods/window_methods.rb new file mode 100644 index 0000000..b855a85 --- /dev/null +++ b/lib/selenium_webdriver_helper/methods/window_methods.rb @@ -0,0 +1,60 @@ +# 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 WindowMethods + + include LoggerEasy + include CommonMethods + + def maximize_window(driver) + block_execution do + driver.manage.window.maximize + log_info '[selenium webdriver helper] window is maximized successfully.' + end # block_execution + end # maximize_window + + def wait_for_new_window + 5.times do + break if window_handles.size > 1 + + sleep SHORTER_WAIT + end + end + + def window_handles + @browser.window_handles + end + + def switch_to_window(handle) + @browser.switch_to.window handle + end + + def window_width + @browser.manage.window.size.width + end + + def window_height + @browser.manage.window.size.height + end + + def resize_browser(height = 200, width = 200) + @browser.manage.window.resize_to(width, height) + end + + def new_window_visible?(window_handle_count) + 5.times do + return true if window_handles.length > window_handle_count + + sleep SHORTER_WAIT + end + false + end + + def close_current_window + @browser.close + end +end diff --git a/lib/selenium_webdriver_helper/selenium_webdriver_helper_class.rb b/lib/selenium_webdriver_helper/selenium_webdriver_helper_class.rb new file mode 100644 index 0000000..bd81085 --- /dev/null +++ b/lib/selenium_webdriver_helper/selenium_webdriver_helper_class.rb @@ -0,0 +1,23 @@ +# frozen_string_literal: true + +require 'logger_easy' +require 'selenium-webdriver' +require_relative 'constants' +require_relative 'methods/common_methods' +require_relative 'methods/javascript_methods' +require_relative 'methods/page_methods' + +# below is the code to make life easier as it already has selenium webdriver methods defined +class SeleniumWebdriverHelperClass + + include LoggerEasy + include CommonMethods + + def initialize(driver, implicit_wait, log_file_name) + logger_easy(log_file_name) + driver.manage.timeouts.implicit_wait = implicit_wait + @driver = driver + @wait = Selenium::WebDriver::Wait.new(timeout: implicit_wait) # seconds + end # initialize + +end # SeleniumWebdriverHelperClass diff --git a/selenium_webdriver_helper.gemspec b/selenium_webdriver_helper.gemspec index 2c567b4..9f628f4 100644 --- a/selenium_webdriver_helper.gemspec +++ b/selenium_webdriver_helper.gemspec @@ -1,24 +1,24 @@ # frozen_string_literal: true -require_relative "lib/selenium_webdriver_helper/version" +require_relative 'lib/selenium_webdriver_helper/version' Gem::Specification.new do |spec| - spec.name = "selenium_webdriver_helper" + spec.name = 'selenium_webdriver_helper' spec.version = SeleniumWebdriverHelper::VERSION - spec.authors = ["amit-singh-bisht"] - spec.email = ["bishtamitsingh98@gmail.com"] + spec.authors = ['amit-singh-bisht'] + spec.email = ['bishtamitsingh98@gmail.com'] - spec.summary = "Write a short summary, because RubyGems requires one." - spec.description = "Write a longer description or delete this line." - spec.homepage = "https://github.com/amit-singh-bisht/selenium_webdriver_helper_ruby" - spec.license = "MIT" - spec.required_ruby_version = ">= 2.5.0" + spec.summary = 'https://bit.ly/selenium_webdriver_helper' + spec.description = 'https://bit.ly/selenium_webdriver_helper' + spec.homepage = 'https://github.com/amit-singh-bisht/selenium_webdriver_helper_ruby' + spec.license = 'MIT' + spec.required_ruby_version = '>= 2.5.0' - spec.metadata["allowed_push_host"] = "https://rubygems.org" + spec.metadata['allowed_push_host'] = 'https://rubygems.org' - spec.metadata["homepage_uri"] = spec.homepage - spec.metadata["source_code_uri"] = "https://github.com/amit-singh-bisht/selenium_webdriver_helper_ruby" - spec.metadata["changelog_uri"] = "https://github.com/amit-singh-bisht/selenium_webdriver_helper_ruby/blob/main/README.md" + spec.metadata['homepage_uri'] = spec.homepage + spec.metadata['source_code_uri'] = 'https://github.com/amit-singh-bisht/selenium_webdriver_helper_ruby' + spec.metadata['changelog_uri'] = 'https://github.com/amit-singh-bisht/selenium_webdriver_helper_ruby/blob/master/README.md' # Specify which files should be added to the gem when it is released. # The `git ls-files -z` loads the files in the RubyGem that have been added into git. @@ -27,9 +27,9 @@ Gem::Specification.new do |spec| (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)}) end end - spec.bindir = "exe" + spec.bindir = 'exe' spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) } - spec.require_paths = ["lib"] + spec.require_paths = ['lib'] # Uncomment to register a new dependency of your gem # spec.add_dependency "example-gem", "~> 1.0"