itms_automation 2.6.9 → 2.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3810d157ec68cf87cc39949f8eb93e440b0e947a8e51fc2434b4243ab8f4bb73
-  data.tar.gz: ad8c3dcef83f02bd5e8844707b4ebd265b9264d74e07cf1e7d1306e1b8b84cd3
+  metadata.gz: 7a0b67a5af9ae7b5abab5f2993983dd70c104608d1895aeed6ad63a034f1f8e0
+  data.tar.gz: 10cdb6858de34421b696c131553f2247663d785cdf2f648bccdfd20a28763aea
 SHA512:
-  metadata.gz: 1b5a86caff363461ef904b6624dbea4ca1f68a7d3cb9fb394f1d4ac4bb20c389205da6971ef76b9afbe9295731997392479669407e718e87d7f4f5f592bca781
-  data.tar.gz: ae167b14afb228b6f83cbd09a9f4a05a6a7c860b7f630dd5b6ef307c3df2388a5628b1d5cb66cca85b4981ac3d8bd6de4945be4a135caff7ec819fd6a0bbd4e5
+  metadata.gz: c2e9ddac84ad149c3cb5d71eaae39cf0710d150d35f0479095696134a5ba3cc2e1bd4f83c40cc2f3c5991c2c69f04e41429ee60fe582aa7000b90c803ab9295c
+  data.tar.gz: 9a628c5bc6d8d62ee7ec9f68756aed60017d7be67585d0ca604c2fd28fbf024b193dd39d240c1f03abb4a4231b9d6f5d013ffd64b9fd081136ee65d9bd3e4f7c

data/features-skeleton/support/env.rb

@@ -7,32 +7,33 @@ require "webdrivers"
 $browser_type = ENV["BROWSER"] || "firefox"
 
 begin
+  $vars = {}
   $driver = case $browser_type
-  when "chrome"
-    Selenium::WebDriver.for(:chrome)
-  when "safari"
-    Selenium::WebDriver.for(:safari)
-  when "internet_explorer"
-    Selenium::WebDriver.for(:internet_explorer)
-  when "chrome_headless"
-    Selenium::WebDriver.for(:chrome, :desired_capabilities => Selenium::WebDriver::Remote::Capabilities.chrome(chromeOptions: { args: %w(headless) }))
-  when "remote"
-    if ENV['SERVER_URL'].nil? || ENV['REMOTE_BROWSER'].nil?
-      puts "\nMissing SERVER_URL : SERVER_URL=http//SERVER_URL:4444/wd/hub"
-      puts "\nMissing REMOTE_BROWSER: REMOTE_BROWSER=browser_name"
-      Process.exit(0)
-    else
-      caps = Selenium::WebDriver::Remote::Capabilities.new
-      caps["browserName"] = ENV["REMOTE_BROWSER"]
-      caps["enableVNC"] = false
-      caps["enableVideo"] = false
-      caps["resolution"] = ENV["resolution"] unless ENV["resolution"]
-      Selenium::WebDriver.for(:remote, :url => ENV["SERVER_URL"], :desired_capabilities => caps)
-  end
+    when "chrome"
+      Selenium::WebDriver.for(:chrome)
+    when "safari"
+      Selenium::WebDriver.for(:safari)
+    when "internet_explorer"
+      Selenium::WebDriver.for(:internet_explorer)
+    when "chrome_headless"
+      Selenium::WebDriver.for(:chrome, :desired_capabilities => Selenium::WebDriver::Remote::Capabilities.chrome(chromeOptions: { args: %w(headless) }))
+    when "remote"
+      if ENV['SERVER_URL'].nil? || ENV['REMOTE_BROWSER'].nil?
+        puts "\nMissing SERVER_URL : SERVER_URL=http//SERVER_URL:4444/wd/hub"
+        puts "\nMissing REMOTE_BROWSER: REMOTE_BROWSER=browser_name"
+        Process.exit(0)
+      else
+        caps = Selenium::WebDriver::Remote::Capabilities.new
+        caps["browserName"] = ENV["REMOTE_BROWSER"]
+        caps["enableVNC"] = false
+        caps["enableVideo"] = false
+        caps["resolution"] = ENV["resolution"] unless ENV["resolution"]
+        Selenium::WebDriver.for(:remote, :url => ENV["SERVER_URL"], :desired_capabilities => caps)
+      end
   else
     Selenium::WebDriver.for(:firefox)
   end
 rescue Exception => e
   puts e.message
   Process.exit(0)
-end
+end

data/lib/itms_automation/methods/assertion_methods.rb

@@ -1,228 +1,208 @@
 require 'net/https'
 require_relative 'required_files'
+require 'rspec'
 
 # This file contains assertion methods which are called from assertion_steps.rb
 
-# Method to return page title
-def get_page_title
-  $driver.title
+# Method to verify title
+# param 1: String : expected title
+def assert_title(title)
+  expect($driver.title).to eq(title)
 end
 
-# Method to verify title
-# param 1 : String : expected title
-# param 2 : Boolean : test case [true or flase]
-def check_title(title, test_case)
-  page_title = get_page_title
-  if test_case
-    if page_title != "#{title}"
-      raise TestCaseFailed, "Page Title Not Matched, Actual Page Title : #{page_title}"
-    end
-  else
-    if page_title == "#{title}"
-      raise TestCaseFailed, "Page Title Matched, Actual Page Title:#{page_title}"
-    end
-  end
+# Method to check element text
+# param 1 : String : Element
+# param 2 : String : Expected element text
+def assert_text(element, expected_value)
+  found_element = find_object(element)
+  element_text = found_element.text
+  expect(element_text).to eq(expected_value)
 end
 
-# Method to verify partial title
-# param 1 : String : partial title string
-# param 2 : Boolean : test case [true or flase]
-def check_partial_title(partial_text_title, test_case)
-  page_title = get_page_title
-  if test_case
-    if not page_title.include? "#{partial_text_title}"
-      raise TestCaseFailed, 'Partial Page Title Not Present'
-    end
-  else
-    if page_title.include? "#{partial_text_title}"
-      raise TestCaseFailed, 'Page Title Matched'
-    end
-  end
+# method to check element presence
+# param 1: String: Element
+def assert_element_present(element)
+  found_element = find_object(element)
+  expect(found_element.length).to be > 0
 end
 
-# Method to get element text
-# param : String
-def get_element_text(element)
-  WAIT.until { find_object(element) }.text
+# method to check element not presence
+# param 1: String: Element
+def assert_element_not_present(element)
+  found_element = find_object(element)
+  expect(found_element.length).to eq(0)
 end
 
-# Method to check element text
+# method to assert checkbox check
 # param 1 : String : Element
-# param 2 : String : Expected element text
-# param 3 : Boolean : test case [true or flase]
-def check_element_text(element, expected_value, test_case)
-  element_text = get_element_text(element)
+def assert_checked(element)
+  checkbox = find_object(element)
+  expect(checkbox.selected?).to be_truthy
+end
 
-  if test_case
-    if element_text != expected_value
-      raise TestCaseFailed, "Text Not Matched. Actual Value :#{expected_value}"
-    end
-  else
-    if element_text == expected_value
-      raise TestCaseFailed, "Text Matched. Actual Value :#{expected_value}"
-    end
-  end
+def assert_not_checked(element)
+  checkbox = find_object(element)
+  expect(checkbox.selected?).to be_falsey
 end
 
-# Method to check partial element text
-# param 1 : String : Element
-# param 2 : String : Expected element partial text
-# param 3 : Boolean : test case [true or flase]
-def check_element_partial_text(element, expected_value, test_case)
-  element_text = get_element_text(element)
-
-  if test_case
-    if not element_text.include? "#{expected_value}"
-      raise TestCaseFailed, "Text Not Matched. Actual Value :#{expected_value}"
-    end
-  else
-    if element_text.include? "#{expected_value}"
-      raise TestCaseFailed, "Text Matched. Actual Value :#{expected_value}"
-    end
-  end
+# method to check javascript pop-up alert text
+def assert_alert(text)
+  alert_text = $driver.switch_to.alert.text
+  expect(alert_text).to eq(text)
 end
 
-# method to return element status - enabled?
-# param : String : Element
-def is_element_enabled(element)
-  WAIT.until{ find_object(element) }.enabled?
+# method to check javascript pop-up alert text
+def assert_confirmation(text)
+  alert_text = $driver.switch_to.alert.text
+  expect(alert_text).to eq(text)
 end
 
-# method to check element status - enabled?
-# param 1 : String : Element
-# param 2 : Boolean : test case [true or flase]
-def check_element_enable(element, test_case)
-  result = is_element_enabled(element)
+def assert_editable(element)
+  found_element = find_object(element)
+  expect(found_element.enabled?).to be_truthy
+end
 
-  if test_case
-    raise TestCaseFailed, 'Element Not Enabled' unless result
-  else
-    raise TestCaseFailed, 'Element Enabled' unless !result
-  end
+def assert_not_editable
+  found_element = find_object(element)
+  expect(found_element.enabled?).to be_falsey
 end
 
-# method to get attribute value
-# param 1 : String : Element
-# param 2 : String : atrribute name
-def get_element_attribute(element, attribute_name)
-  WAIT.until{ find_object(element) }.attribute("#{attribute_name}")
+def assert_not_selected_value(element, text)
+  found_element = find_object(element)
+  value = found_element.attribute("value")
+  expect(value).not_to eq(text)
 end
 
-# method to check attribute value
-# param 1 : String : Element
-# param 2 : String : atrribute name
-# param 3 : String : atrribute value
-# param 4 : Boolean : test case [true or flase]
-def check_element_attribute(element, attribute_name, attribute_value, test_case)
+def assert_not_text(element, text)
+  found_element = find_object(element)
+  expect(found_element.text).not_to eq(text)
+end
+
+def assert_prompt(text)
+  alert_text = $driver.switch_to.alert.text
+  expect(alert_text).to eq(text)
+end
 
-  attr_val = get_element_attribute(element, attribute_name)
+def assert_selected_label(element, text)
+  found_element = find_object(element)
+  locator = "option[@value='#{found_element.attribute('value')}']"
+  selected_text = found_element.find_element(:xpath, locator).text
+  expect(selected_text).to eq(text)
+end
 
-  if test_case
-    if attr_val != attribute_value
-      raise TestCaseFailed, "Attribute Value Not Matched. Actual Value :#{attr_val}"
-    end
-  else
-    if attr_val == attribute_value
-      raise TestCaseFailed, "Attribute Value Matched. Actual Value :#{attr_val}"
-    end
-  end
+def assert_value(element, text)
+  found_element = find_object(element)
+  value = found_element.attribute("value")
+  expect(value).to eq(text)
 end
 
-# method to get element status - displayed?
-# param : String : Element
-def is_element_displayed(element)
-  WAIT.until{ find_object(element) }.displayed?
+def assert_selected_value
+  found_element = find_object(element)
+  value = found_element.attribute("value")
+  expect(value).to eq(text)
 end
 
-# method to check element presence
-# param 1 : String : Element
-# param 2 : Boolean : test case [true or flase]
-def check_element_presence(element, test_case)
-  if test_case
-    if !is_element_displayed(element)
-      raise TestCaseFailed, 'Element Not Present'
-    end
-  else
-    begin
-      if is_element_displayed(element)
-        raise 'Present' # since it is negative test and we found element
-      end
-    rescue Exception => e
-      if e.message == 'Present' # only raise if it present
-        raise TestCaseFailed, 'Element Present'
-      end
-    end
+def assert(var_name, value)
+  if (value == "true" || value == "false")
+    _value = value
+  else elseif (value == '0' || !!number_or_nil(value)) {
+    _value = value
   end
+  result = _value
+    ? expect($vars[var_name]).to eq(_value)
+    : expect($vars[var_name]).to eq(value)
+end
+
+# Method to verify title
+# param 1: String : expected title
+def verify_title(title)
+  expect($driver.title).to eq(title)
 end
 
-# method to assert checkbox check/uncheck
+# Method to check element text
 # param 1 : String : Element
-# param 2 : Boolean : test case [true or flase]
-def is_checkbox_checked(element, should_be_checked = true)
-  checkbox = WAIT.until{ find_object(element) }
-
-  if !checkbox.selected? && should_be_checked
-    raise TestCaseFailed, 'Checkbox is not checked'
-  elsif checkbox.selected? && !should_be_checked
-    raise TestCaseFailed, 'Checkbox is checked'
-  end
+# param 2 : String : Expected element text
+def verify_text(element, expected_value)
+  found_element = find_object(element)
+  element_text = found_element.text
+  expect(element_text).to eq(expected_value)
+end
+
+# method to check element presence
+# param 1: String: Element
+def verify_element_present(element)
+  found_element = find_object(element)
+  expect(found_element.length).to be > 0
 end
 
-# method to assert radio button selected/unselected
+# method to check element not presence
+# param 1: String: Element
+def verify_element_not_present(element)
+  found_element = find_object(element)
+  expect(found_element.length).to eq(0)
+end
+
+# method to assert checkbox check
 # param 1 : String : Element
-# param 2 : Boolean : test case [true or flase]
-def is_radio_button_selected(element, should_be_selected = true)
-  radio_button = WAIT.until{ find_object(element) }
-
-  if !radio_button.selected? && should_be_selected
-    raise TestCaseFailed, 'Radio Button not selected'
-  elsif radio_button.selected? && !should_be_selected
-    raise TestCaseFailed, 'Radio Button is selected'
-  end
+def verify_checked(element)
+  checkbox = find_object(element)
+  expect(checkbox.selected?).to be_truthy
 end
 
-# method to assert option from radio button group is selected/unselected
-def is_option_from_radio_button_group_selected(element, by, option, should_be_selected = true)
-  radio_button_group = WAIT.until{ find_object(element) }
+def verify_not_checked(element)
+  checkbox = find_object(element)
+  expect(checkbox.selected?).to be_falsey
+end
 
-  getter = ->(rb, by) { by == 'value' ? rb.attribute('value') : rb.text }
+def verify_editable(element)
+  found_element = find_object(element)
+  expect(found_element.enabled?).to be_truthy
+end
 
-  ele = radio_button_group.find { |rb| getter.call(rb, by) == option }
+def verify_not_editable
+  found_element = find_object(element)
+  expect(found_element.enabled?).to be_falsey
+end
 
-  if !ele.selected? && should_be_selected
-    raise TestCaseFailed, 'Radio button is not selected'
-  elsif ele.selected? && !should_be_selected
-    raise TestCaseFailed, 'Radio button is selected'
-  end
+def verify_not_selected_value(element, text)
+  found_element = find_object(element)
+  value = found_element.attribute("value")
+  expect(value).not_to eq(text)
 end
 
-# method to get javascript pop-up alert text
-def get_alert_text
-  $driver.switch_to.alert.text
+def verify_not_text(element, text)
+  found_element = find_object(element)
+  expect(found_element.text).not_to eq(text)
 end
 
-# method to check javascript pop-up alert text
-def check_alert_text(text)
-  if get_alert_text != text
-    raise TestCaseFailed,  "Text on alert pop up not matched. Actual Value :#{get_alert_text}"
-  end
+def verify_selected_label(element, text)
+  found_element = find_object(element)
+  locator = "option[@value='#{found_element.attribute('value')}']"
+  selected_text = found_element.find_element(:xpath, locator).text
+  expect(selected_text).to eq(text)
 end
 
-def is_option_from_dropdown_selected(element, by, option, should_be_selected=true)
-  dropdown = WAIT.until { find_object(element) }
-  select_list = Selenium::WebDriver::Support::Select.new(dropdown)
+def verify_value(element, text)
+  found_element = find_object(element)
+  value = found_element.attribute("value")
+  expect(value).to eq(text)
+end
 
-  if by == 'text'
-    actual_value = select_list.first_selected_option.text
-  else
-    actual_value = select_list.first_selected_option.attribute('value')
-  end
+def verify_selected_value
+  found_element = find_object(element)
+  value = found_element.attribute("value")
+  expect(value).to eq(text)
+end
 
-  if !actual_value == option && should_be_selected
-    raise TestCaseFailed, 'Option Not Selected From Dropwdown'
-  elsif actual_value == option && !should_be_selected
-    raise TestCaseFailed, 'Option Selected From Dropwdown'
-  end
+def verify(var_name, value)
+  if (value == "true" || value == "false") {
+    _value = value
+  } elseif (value == '0' || !!number_or_nil(value)) {
+    _value = value
+  }
+  result = _value
+    ? expect($vars[var_name]).to eq(_value)
+    : expect($vars[var_name]).to eq(value)
 end
 
 # Method to find difference between images
@@ -331,3 +311,8 @@ def compare_png_images(expected_img_url, actual_img_url)
   end
   true
 end
+
+def number_or_nil(string)
+  num = string.to_i
+  num if num.to_s == string
+end

data/lib/itms_automation/methods/click_elements_methods.rb

@@ -1,20 +1,27 @@
 require_relative 'required_files'
 
 def click(element)
-  WAIT.until { find_object(element) }.click
+  found_element = find_object(element)
+  found_element.click
 end
 
-def click_forcefully(element)
-  $driver.execute_script('arguments[0].click();', WAIT.until { find_object(element) })
+def click_at(element)
+  found_element = find_object(element)
+  found_element.click
 end
 
 def double_click(element)
-  found_element = WAIT.until { find_object(element) }
+  found_element = find_object(element)
   $driver.action.double_click(found_element).perform
 end
 
-def long_press( element, duration)
-  found_element = WAIT.until { find_object(element) }
+def double_click_at(element, location)
+  found_element = find_object(element)
+  $driver.action.double_click(found_element).perform
+end
+
+def long_press(element, duration)
+  found_element = find_object(element)
   parameters = { "element" => "#{found_element}", "duration" => "#{duration}" }
   args = parameters.select { |k, v| [:element, :duration].include? k }
   args = args_with_ele_ref(args)

data/lib/itms_automation/methods/condition_methods.rb

@@ -0,0 +1,13 @@
+require_relative 'required_files'
+
+def if(condition_script)
+  return $driver.execute_script(condition_script)
+end
+
+def else_if(condition_script)
+  return $driver.execute_script(condition_script)
+end
+
+def while(condition_script)
+  return $driver.execute_script(condition_script)
+end

data/lib/itms_automation/methods/configuration_methods.rb

@@ -7,9 +7,9 @@ def print_congifugartion
   puts "Time : #{Time.now.strftime("%I:%M:%S:%p")}"
 
   if $platform == 'android' or $platform == 'ios'
-  	print_mobile_configuration
+    print_mobile_configuration
   else
-  	print_desktop_configuration
+    print_desktop_configuration
   end
 end
 
@@ -22,14 +22,21 @@ end
 
 # method to print mobile configuration
 def print_mobile_configuration
-  puts "Platform : #{$platform.upcase}" 
-  puts "OS version : #{$os_version}" 
-  puts "Device : #{$device_name}" 
+  puts "Platform : #{$platform.upcase}"
+  puts "OS version : #{$os_version}"
+  puts "Device : #{$device_name}"
 
   if $app_path.nil?
-  	puts 'Browser : ' + $driver.capabilities.browser_name.to_s.upcase + " " + $driver.capabilities.version.to_s
+    puts 'Browser : ' + $driver.capabilities.browser_name.to_s.upcase + " " + $driver.capabilities.version.to_s
   else
-  	puts "App Tested : #{$app_path}" 
+    puts "App Tested : #{$app_path}"
   end
   puts ''
 end
+
+def echo(message)
+  puts(message)
+end
+
+def debugger
+end

data/lib/itms_automation/methods/input_methods.rb

@@ -1,15 +1,21 @@
 require_relative 'required_files'
 
 # method to enter text into textfield
-def enter_text(element, text)
+def type(element, text)
   foundElement = find_object(element)
-  WAIT.until { foundElement }.send_keys(text)
+  foundElement.send_keys(text)
 end
 
-# method to clear text from textfield
-def clear_text(element)
+# method to send keys
+def send_keys(element, key)
+  keys_support = ["KEY_LEFT", "KEY_UP", "KEY_RIGHT", "KEY_DOWN", "KEY_PAGE_UP", "KEY_PAGE_DOWN", "KEY_BACKSPACE", "KEY_DELETE", "KEY_ENTER", "KEY_TAB"]
   foundElement = find_object(element)
-  WAIT.until { foundElement }.clear
+  if key
+    get_key = key.strip[/^\$\{(.*?)\}$/, 1]
+    raise TestCaseFailed, "${get_key} key is not supported. Supported keys: KEY_LEFT, KEY_UP, KEY_RIGHT, KEY_DOWN, KEY_PAGE_UP, KEY_PAGE_DOWN, KEY_BACKSPACE, KEY_DELETE, KEY_ENTER, KEY_TAB" unless keys_support.include?(get_key)
+    key_convert = get_key[/^KEY_(.*?)$/, 1].downcase.to_sym
+    foundElement.send_keys(key_convert)
+  end
 end
 
 # method to select option from dropdwon list
@@ -34,23 +40,20 @@ def unselect_all_option_from_multiselect_dropdown(element)
 end
 
 # method to check checkbox
-def check_checkbox(element)
-  checkbox = WAIT.until { find_object(element) }
+def check(element)
+  checkbox = find_object(element)
   checkbox.click unless checkbox.selected?
 end
 
 # method to uncheck checkbox
-def uncheck_checkbox(element)
-  checkbox = WAIT.until { find_object(element) }
-
-  if checkbox.selected?
-    checkbox.click
-  end
+def uncheck(element)
+  checkbox = find_object(element)
+  checkbox.click if checkbox.selected?
 end
 
-# method to select radio button
+# method to toggle checkbox checked
 def toggle_checkbox(element)
-  WAIT.until { find_object(element) }.click
+  find_object(element).click
 end
 
 # method to select radio button
@@ -67,3 +70,43 @@ def select_option_from_radio_button_group(element, by, option)
   ele = radio_button_group.find { |rb| getter.call(rb, by) == option }
   ele.click unless ele.selected?
 end
+
+def edit_content(element, text)
+  found_element = find_object(element)
+  $driver.execute_script("if (arguments[0].contentEditable === 'true') {arguments[0].innerText = '#{text}'}", found_element)
+end
+
+def add_selection(label)
+  found_element = find_object(element)
+  found_element.find_element(:xpath, "//option[. = '#{label}']").click
+end
+
+def remove_selection
+  found_element = find_object(element)
+  found_element.find_element(:xpath, "//option[. = '#{label}']").click
+end
+
+def select
+  found_element = find_object(element)
+  found_element.find_element(:xpath, "//option[. = '#{label}']").click
+end
+
+def drag_and_drop_to_object(element, drop_element)
+  dragged = find_object(element)
+  object_value_regex = /^(class=|css=|id=|name=|xpath=|className=|link=|linkText=|partialLinkText=)/
+  object_type_regex = /^(class|css|id|name|xpath|className|link|linkText|partialLinkText)/
+  if object_value_regex.match?(drop_element)
+    object_value = drop_element.gsub(object_value_regex, "")
+    object_type = drop_element.split(object_type_regex)[1].underscore
+    dropped = $driver.find_element(object_type.to_sym, object_value)
+    $driver.action.drag_and_drop(dragged, dropped).perform
+  else
+    raise TestCaseFailed, "Option locator not supported"
+  end
+end
+
+def select_window(element)
+end
+
+def select_frame(element)
+end

data/lib/itms_automation/methods/javascript_handling_methods.rb

@@ -4,6 +4,6 @@ def handle_alert(decesion)
   if decesion == 'accept'
     $driver.switch_to.alert.accept
   else
-   	$driver.switch_to.alert.dismiss
+    $driver.switch_to.alert.dismiss
   end
 end

data/lib/itms_automation/methods/misc_methods.rb

@@ -59,6 +59,6 @@ def loadYAMLfile(filename)
   begin
     return YAML.load_file(filename)
   rescue Psych::SyntaxError => ex
-    raise "❌ SyntaxError when reading file: #{ex}"
+    raise "Syntax error when reading file: #{ex}"
   end
 end

data/lib/itms_automation/methods/navigate_methods.rb

@@ -1,21 +1,25 @@
 require_relative 'required_files'
 
 # method to open link
-def navigate_to(link)
+def open(link)
   $driver.get link
 end
 
 # method to navigate back & forward
 def navigate(direction)
   if direction == 'back'
-	  $driver.navigate.back
+    $driver.navigate.back
   else
     $driver.navigate.forward
   end
 end
 
+def close
+  $drive.close
+end
+
 # method to quite webdriver instance
-def close_driver
+def quit
   $driver.quit
 end
 
@@ -39,7 +43,7 @@ end
 # Method to zoom in/out web page until web element dislays
 def zoom_in_out_till_element_display(element, in_out)
   while true
-    if WAIT.until { find_object(element) }.displayed?
+    if find_object(element).displayed?
       break
     else
       $driver.action.key_down(:"#{get_key}").send_keys(:"#{in_out}").key_up(:"#{get_key}").perform
@@ -48,8 +52,10 @@ def zoom_in_out_till_element_display(element, in_out)
 end
 
 # Method to resize browser
-def resize_browser(width, heigth)
-  $driver.manage.window.resize_to(width, heigth)
+def set_window_size(resolution)
+  raise TestCaseFailed, 'Wrong format of resolution. (e.g., 1280x800)' unless resolution.match(/^\d+x\d+$/)
+  width, height = resolution.split("x")
+  $driver.manage.resize_to(width, heigth)
 end
 
 # Method to maximize browser
@@ -63,14 +69,50 @@ def refresh_page
 end
 
 # Method to hover on element
-def hover_over_element(element)
-  element = WAIT.until { find_object(element) }
-  $driver.action.move_to(element).perform
+def mouse_over(element)
+  element = find_object(element)
+  $driver.action.move_to_element(element).perform
+end
+
+# mouse_down
+def mouse_down(element)
+  element = find_object(element)
+  $driver.action.move_to_element(element).click_and_hold.perform
+end
+
+# mouse_down_at
+def mouse_down_at(element, location)
+  element = find_object(element)
+  $driver.action.move_to_element(element).click_and_hold.perform
+end
+
+# mouse_out
+def mouse_out
+  element = $driver.find_element(By.CSS_SELECTOR, 'body')
+  $driver.action.move_to_element(element, 0, 0).perform
+end
+
+#mouse_up
+def mouse_up(element)
+  element = find_object(element)
+  $driver.action.move_to_element(element).release.perform
+end
+
+#mouse_up_at
+def mouse_up_at
+  element = find_object(element)
+  $driver.action.move_to_element(element).release.perform
+end
+
+#mouse_move_at
+def mouse_move_at
+  element = find_object(element)
+  $driver.action.move_to_element(element).perform
 end
 
 # Method to scroll page to perticular element
 def scroll_to_element(element)
-  ele_scroll = WAIT.until { find_object(element) }
+  ele_scroll = find_object(element)
   ele_scroll.location_once_scrolled_into_view
 end
 
@@ -84,38 +126,3 @@ def scroll_page(to)
     raise "Exception : Invalid Direction (only scroll \"top\" or \"end\")"
   end
 end
-
-$old_win = nil
-
-# Method to switch to new window
-def switch_to_new_window
-  $old_win = $driver.window_handle
-  $driver.switch_to.window($driver.window_handles[1])
-end
-
-# Method to switch to old window
-def switch_to_old_window
-  $driver.switch_to.window($old_win)
-end
-
-# Method to close new window
-def close_new_window
-  $driver.close
-end
-
-=begin
-def switch_to_new_window
-  win_handles = $driver.window_handles
-
-  puts $driver.title
-  puts win_handles.length
-
-  $driver.switch_to.window($driver.window_handles[1])
-  puts $driver.window_handles[1]
-  puts $driver.title
-
-  $driver.switch_to.window($driver.window_handles[2])
-  puts $driver.window_handles[2]
-  puts $driver.title
-end
-=end

data/lib/itms_automation/methods/progress_methods.rb

@@ -1,15 +1,82 @@
 require_relative 'required_files'
 
-def wait(time)
+def pause(time)
   sleep time.to_i
 end
 
-def wait_for_element_to_display(element, duration)
-  wait = Selenium::WebDriver::Wait.new(:timeout => duration.to_i) # seconds
+def wait_for_element_editable(element, duration)
+  wait = Selenium::WebDriver::Wait.new(:timeout => duration.to_i / 1000)
+  wait.until { find_object(element).enabled? }
+end
+
+def wait_for_element_not_editable(element, duration)
+  wait = Selenium::WebDriver::Wait.new(:timeout => duration.to_i / 1000)
+  wait.until { !find_object(element).enabled? }
+end
+
+def wait_for_element_not_present(element, duration)
+  wait = Selenium::WebDriver::Wait.new(:timeout => duration.to_i / 1000)
+  wait.until do
+    begin
+      !find_object(element)
+    rescue Selenium::WebDriver::Error::NoSuchElementError
+      true
+    end
+  end
+end
+
+def wait_for_element_not_visible(element, duration)
+  wait = Selenium::WebDriver::Wait.new(:timeout => duration.to_i / 1000)
+  wait.until { !find_object(element).displayed? }
+end
+
+def wait_for_text(element, text)
+  wait = Selenium::WebDriver::Wait.new(:timeout => 30)
+  wait.until { find_object(element).text == text }
+end
+
+def wait_for_element_visible(element, duration)
+  wait = Selenium::WebDriver::Wait.new(:timeout => duration.to_i / 1000)
   wait.until { find_object(element).displayed? }
 end
 
-def wait_for_element_to_enable(element, duration)
-  wait = Selenium::WebDriver::Wait.new(:timeout => duration.to_i) # seconds
-  wait.until { find_object(element).enabled? }
+def wait_for_element_present(element, duration)
+  wait = Selenium::WebDriver::Wait.new(:timeout => duration.to_i / 1000)
+  wait.until { find_object(element) }
+end
+
+def answer_on_next_prompt(answer)
+  alert = $driver.switch_to.alert
+  alert.send_keys(answer)
+  alert.accept()
+end
+
+def choose_cancel_on_next_confirmation
+  $driver.switch_to.alert.dismiss
+end
+
+def choose_cancel_on_next_prompt
+  $driver.switch_to.alert.dismiss
+end
+
+def choose_ok_on_next_confirmation
+  $driver.switch_to.alert.accept
+end
+
+def webdriver_answer_on_visible_prompt
+  alert = $driver.switch_to.alert
+  alert.send_keys(answer)
+  alert.accept()
+end
+
+def webdriver_choose_cancel_on_visible_confirmation
+  $driver.switch_to.alert.dismiss
+end
+
+def webdriver_choose_ok_on_visible_confirmation
+  $driver.switch_to.alert.accept
+end
+
+def webdriver_choose_cancel_on_visible_prompt
+  $driver.switch_to.alert.dismiss
 end

data/lib/itms_automation/methods/store_methods.rb

@@ -0,0 +1,36 @@
+require 'net/https'
+require_relative 'required_files'
+require 'rspec'
+
+def store(var_name, value)
+  $vars[var_name] = value
+end
+
+def store_json(var_name, value)
+  $vars[var_name] = JSON.parse(value)
+end
+
+def store_text(element, var_name)
+  found_element = find_object(element)
+  element_text = found_element.text
+  $vars[var_name] = element_text
+end
+
+def store_title(var_name)
+  $vars[var_name] = $driver.title
+end
+
+def store_xpath_count(element, var_name)
+  found_element = find_object(element)
+  $vars[var_name] = found_element.length
+end
+
+def store_window_handle(var_name)
+  $vars[var_name] = $driver.window_handle
+end
+
+def store_attribute(element, attribute, var_name)
+  found_element = find_object(element)
+  value = found_element.attribute(attribute)
+  $vars[var_name] = value
+end

data/lib/itms_automation/version.rb

@@ -1,5 +1,5 @@
 module ITMS
   module Automation
-    VERSION = '2.6.9'
+    VERSION = '2.7.4'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: itms_automation
 version: !ruby/object:Gem::Version
-  version: 2.6.9
+  version: 2.7.4
 platform: ruby
 authors:
 - INFOdation
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-28 00:00:00.000000000 Z
+date: 2021-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber
@@ -110,6 +110,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.5'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.5'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
 description: Behavior driven development (BDD) approach to write automation test script
   to test Web and Android applications.
 email: anh.pham@infodation.vn
@@ -149,6 +169,7 @@ files:
 - lib/itms_automation/javascript_handling_steps.rb
 - lib/itms_automation/methods/assertion_methods.rb
 - lib/itms_automation/methods/click_elements_methods.rb
+- lib/itms_automation/methods/condition_methods.rb
 - lib/itms_automation/methods/configuration_methods.rb
 - lib/itms_automation/methods/error_handling_methods.rb
 - lib/itms_automation/methods/input_methods.rb
@@ -158,6 +179,7 @@ files:
 - lib/itms_automation/methods/progress_methods.rb
 - lib/itms_automation/methods/required_files.rb
 - lib/itms_automation/methods/screenshot_methods.rb
+- lib/itms_automation/methods/store_methods.rb
 - lib/itms_automation/navigation_steps.rb
 - lib/itms_automation/progress_steps.rb
 - lib/itms_automation/screenshot_steps.rb
@@ -181,7 +203,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: SELENIUM WEBDRIVER WITH RUBY & CUCUMBER