itms_automation 2.5 → 2.5.6

data/lib/itms_automation/click_elements_steps.rb

@@ -0,0 +1,24 @@
+# require 'cucumber'
+# require_relative 'methods/click_elements_methods'
+
+# # click on web element
+# When(/^I click on element"(.*?)"$/) do |element|
+#   click(element)
+# end
+
+# Then(/^I forcefully click on element "(.*?)"$/) do |element|
+#   click_forcefully(element)
+# end
+
+# # double click on web element
+# Then(/^I double click on element "(.*?)"$/) do |element|
+#   double_click(element)
+# end
+
+# When(/^I tap on element"(.*?)"$/) do |element|
+#   click(element)
+# end
+
+# Then(/^I long press on element "(.*?)"$/) do |element|
+#   long_press(element, duration)
+# end

data/lib/itms_automation/configuration_steps.rb

@@ -0,0 +1,7 @@
+# require 'cucumber'
+# require_relative 'methods/configuration_methods'
+
+# # step to print configuration
+# Then(/^I print configuration$/) do
+#   print_congifugartion
+# end

data/lib/itms_automation/input_steps.rb

@@ -0,0 +1,59 @@
+# require 'cucumber'
+# require_relative 'methods/input_methods'
+
+# # enter text into input field steps
+# Then(/^I enter "([^\"]*)" into element "(.*?)"$/) do |text, element|
+#   enter_text(type, element)
+# end
+
+# # clear input field steps
+# Then(/^I clear input element "(.*?)"$/) do |type, element|
+#   clear_text(type, element)
+# end
+
+# # select option by text/value from dropdown/multiselect
+# Then(/^I select "(.*?)" option by (.+) from\s*((?:multiselect)?)\sdropdown "(.*?)"$/) do |option, option_by, present, element|
+#   validate_option_by option_by
+#   select_option_from_dropdown(element, option_by, option)
+# end
+
+# # select option by index from dropdown/multiselect
+# Then(/^I select (\d+) option by index from\s*((?:multiselect)?)\sdropdown "(.*?)"$/) do |option, present, element|
+#   select_option_from_dropdown(element, 'index', (option.to_i) -1)
+# end
+
+# # step to select option from mutliselect dropdown list
+# Then(/^I select all options from multiselect dropdown "(.*?)"$/) do |element|
+#   select_all_option_from_multiselect_dropdown(element)
+# end
+
+# # step to unselect option from mutliselect dropdown list
+# Then(/^I unselect all options from multiselect dropdown "(.*?)"$/) do |element|
+#   unselect_all_option_from_multiselect_dropdown(element)
+# end
+
+# # check checkbox steps
+# Then(/^I check the checkbox "(.*?)"$/) do |element|
+#   check_checkbox(element)
+# end
+
+# # uncheck checkbox steps
+# Then(/^I uncheck the checkbox "(.*?)"$/) do |element|
+#   uncheck_checkbox(element)
+# end
+
+# # steps to toggle checkbox
+# Then(/^I toggle checkbox "(.*?)"$/) do |element|
+#   toggle_checkbox(element)
+# end
+
+# # step to select radio button
+# Then(/^I select radio button "(.*?)"$/) do |element|
+#   select_radio_button(element)
+# end
+
+# # steps to select option by text from radio button group
+# Then(/^I select "(.*?)" option by (.+) from radio button group "(.*?)"$/) do |option, option_by, element|
+#   validate_option_by option_by
+#   select_option_from_radio_button_group(element, option_by, option)
+# end

data/lib/itms_automation/javascript_handling_steps.rb

@@ -0,0 +1,10 @@
+# require 'cucumber'
+# require_relative 'methods/javascript_handling_methods'
+
+# Then(/^I accept alert$/) do
+#   handle_alert('accept')
+# end
+
+# Then(/^I dismiss alert$/) do
+#   handle_alert('dismiss')
+# end

data/lib/itms_automation/methods/assertion_methods.rb

@@ -0,0 +1,344 @@
+require 'net/https'
+require_relative 'required_files'
+
+# This file contains assertion methods which are called from assertion_steps.rb
+
+# Method to return page title
+def get_page_title
+  $driver.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
+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
+end
+
+# Method to get element text
+# param 1 : String : Locator type (id, name, class, xpath, css)
+# param 2 : String : Locator value
+def get_element_text(element)
+  WAIT.until { find_object(element) }.text
+end
+
+# Method to check element text
+# param 1 : String : Locator type (id, name, class, xpath, css)
+# param 2 : String : Expected element text
+# param 3 : String : Locator value
+# param 4 : Boolean : test case [true or flase]
+def check_element_text(element, actual_value, test_case)
+  element_text = get_element_text(element)
+
+  if test_case
+    if element_text != actual_value
+      raise TestCaseFailed, 'Text Not Matched'
+    end
+  else
+    if element_text == actual_value
+      raise TestCaseFailed, 'Text Matched'
+    end
+  end
+end
+
+# Method to check partial element text
+# param 1 : String : Locator type (id, name, class, xpath, css)
+# param 2 : String : Expected element partial text
+# param 3 : String : Locator value
+# param 4 : Boolean : test case [true or flase]
+def check_element_partial_text(element, actual_value, test_case)
+  element_text = get_element_text(element)
+
+  if test_case
+    if not element_text.include? "#{actual_value}"
+      raise TestCaseFailed, 'Text Not Matched'
+    end
+  else
+    if element_text.include? "#{actual_value}"
+      raise TestCaseFailed, 'Text Matched'
+    end
+  end
+end
+
+# Method to return element status - enabled?
+# param 1 : String : Locator type (id, name, class, xpath, css)
+# param 2 : String : Locator value
+def is_element_enabled(element)
+  WAIT.until{ find_object(element) }.enabled?
+end
+
+# Element enabled checking
+# param 1 : String : Locator type (id, name, class, xpath, css)
+# param 2 : String : Expected element text
+# param 4 : Boolean : test case [true or flase]
+def check_element_enable(element, test_case)
+  result = is_element_enabled(element)
+
+  if test_case
+    raise TestCaseFailed, 'Element Not Enabled' unless result
+  else
+    raise TestCaseFailed, 'Element Enabled' unless !result
+  end
+end
+
+# method to get attribute value
+# param 1 : String : Locator type (id, name, class, xpath, css)
+# param 2 : String : Expected element text
+# param 3 : String : atrribute name
+def get_element_attribute(element, attribute_name)
+  WAIT.until{ find_object(element) }.attribute("#{attribute_name}")
+end
+
+# method to check attribute value
+# param 1 : String : Locator type (id, name, class, xpath, css)
+# param 2 : String : atrribute name
+# param 3 : String : atrribute value
+# param 4 : String : Locator value
+# param 5 : Boolean : test case [true or flase]
+def check_element_attribute(element, attribute_name, attribute_value, test_case)
+
+  attr_val = get_element_attribute(element, attribute_name)
+
+  if test_case
+    if attr_val != attribute_value
+      raise TestCaseFailed, 'Attribute Value Not Matched'
+    end
+  else
+    if attr_val == attribute_value
+      raise TestCaseFailed, 'Attribute Value Matched'
+    end
+  end
+end
+
+# method to get element status - displayed?
+# param 1 : String : Locator type (id, name, class, xpath, css)
+# param 2 : String : Locator value
+def is_element_displayed(access_type, access_name)
+  WAIT.until{ find_object(element) }.displayed?
+end
+
+# method to check element presence
+# param 1 : String : Locator type (id, name, class, xpath, css)
+# param 2 : String : Locator value
+# param 3 : 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
+  end
+end
+
+# method to assert checkbox check/uncheck
+# param 1 : String : Locator type (id, name, class, xpath, css)
+# param 2 : String : Locator value
+# param 3 : 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
+end
+
+# method to assert radio button selected/unselected
+# param 1 : String : Locator type (id, name, class, xpath, css)
+# param 2 : String : Locator value
+# param 3 : 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
+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) }
+
+  getter = ->(rb, by) { by == 'value' ? rb.attribute('value') : rb.text }
+
+  ele = radio_button_group.find { |rb| getter.call(rb, by) == option }
+
+  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
+end
+
+# method to get javascript pop-up alert text
+def get_alert_text
+  $driver.switch_to.alert.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'
+  end
+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)
+
+  if by == 'text'
+    actual_value = select_list.first_selected_option.text
+  else
+    actual_value = select_list.first_selected_option.attribute('value')
+  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
+end
+
+# Method to find difference between images
+def does_images_similar?(actual_img_access_type, actual_img_access_name, excp_img_access_type, excp_img_access_name)
+  if !compare_image(actual_img_access_type, actual_img_access_name, excp_img_access_type, excp_img_access_name)
+    raise TestCaseFailed, 'Actual image is different from expected image'
+  end
+end
+
+# Method to compare two images
+# param 1 : String : Locator type (id, name, class, xpath, css, url)
+# param 2 : String : Locator value
+# param 3 : String : Locator type (id, name, class, xpath, css, url, image_name)
+# param 4 : String : Locator value
+def compare_image(actual_img_access_type, actual_img_access_name, excp_img_access_type, excp_img_access_name)
+  if actual_img_access_type == 'url'
+    actual_img_url = actual_img_access_name
+  else
+    actual_img_url = get_element_attribute(actual_img_access_type, actual_img_access_name, 'src')
+  end
+
+  if excp_img_access_type == 'url'
+    expected_img_url = excp_img_access_name
+  elsif excp_img_access_type == 'image_name'
+    expected_img_url = './features/expected_images/' + excp_img_access_name
+  else
+    expected_img_url = get_element_attribute(excp_img_access_type, excp_img_access_name, 'src')
+  end
+
+  # replace 'https' with 'http' from actual image url
+  if actual_img_url.include? 'https'
+    actual_img_url['https'] = 'http'
+  end
+
+  # replace 'https' with 'http' from expected image url
+  if expected_img_url.include? 'https'
+    expected_img_url['https'] = 'http'
+  end
+
+  if expected_img_url.include? '.png'
+    image_type = 'png'
+  else
+    image_type = 'jpg'
+  end
+
+  # Storing actual image locally
+  open('./features/actual_images/actual_image.' + image_type, 'wb') do |file|
+    file << open(actual_img_url).read
+  end
+
+  actual_img_url = './features/actual_images/actual_image.' + image_type
+
+  # Storing Expected image locally
+  if excp_img_access_type != 'image_name'
+    open('./features/expected_images/expected_image.' + image_type, 'wb') do |file|
+      file << open(expected_img_url).read
+    end
+    expected_img_url = './features/expected_images/expected_image.' + image_type
+  end
+
+  # Verify image extension and call respective compare function
+  if image_type == 'png'
+    return compare_png_images(expected_img_url, actual_img_url)
+  end
+
+  compare_jpeg_images(expected_img_url, actual_img_url)
+end
+
+# Comparing jpg images
+def compare_jpeg_images(expected_img_url, actual_img_url)
+  if open(expected_img_url).read == open(actual_img_url).read
+    return true
+  else
+    puts 'Difference in images'
+    return false
+  end
+end
+
+# Comparing png images
+def compare_png_images(expected_img_url, actual_img_url)
+  images = [
+    ChunkyPNG::Image.from_file(expected_img_url),
+    ChunkyPNG::Image.from_file(actual_img_url)
+  ]
+
+  diff = []
+
+  images.first.height.times do |y|
+    images.first.row(y).each_with_index do |pixel, x|
+      diff << [x, y] unless pixel == images.last[x, y]
+    end
+  end
+
+  if diff.length != 0
+    puts "\npixels (total):     #{images.first.pixels.length}"
+    puts "pixels changed:     #{diff.length}"
+    puts "pixels changed (%): #{(diff.length.to_f / images.first.pixels.length) * 100}%"
+
+    x, y = diff.map { |xy| xy[0] }, diff.map { |xy| xy[1] }
+    images.last.rect(x.min, y.min, x.max, y.max, ChunkyPNG::Color.rgb(0, 255, 0))
+    cur_time = Time.now.strftime('%Y%m%d%H%M%S%L')
+    images.last.save("./features/image_difference/difference_#{cur_time}.png")
+
+    puts "\nDifference between images saved as : difference_#{cur_time}.png\n"
+    return false
+  end
+  true
+end

data/lib/itms_automation/methods/click_elements_methods.rb

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