itms_automation 2.5 → 2.6.2

data/features-skeleton/my_first.feature

@@ -0,0 +1,10 @@
+Feature: Addition
+  As a math idiot
+  In order to not feel silly
+  I add two numbers
+
+  Scenario: Adding a and b
+    Given I have variable a
+    And I have variable b
+    When I add a and b
+    Then I display the sum

data/features-skeleton/step_definitions/custom_steps.rb

@@ -0,0 +1,5 @@
+require 'itms_automation'
+
+# Do Not Remove This File
+# Add your custom steps here
+# $driver is instance of webdriver use this instance to write your custom code

data/features-skeleton/step_definitions/repositories/project_object.yml

@@ -0,0 +1 @@
+button: { id: 'submit' }

data/features-skeleton/support/env.rb

@@ -0,0 +1,105 @@
+require "rubygems"
+require "itms_automation"
+require "httparty"
+require "cucumber"
+require "report_builder"
+require "selenium-webdriver"
+
+$browser_type = ENV["BROWSER"] || "firefox"
+$platform = ENV["PLATFORM"] || "desktop"
+$os_version = ENV["OS_VERSION"]
+$device_name = ENV["DEVICE_NAME"]
+$udid = ENV["UDID"]
+$app_path = ENV["APP_PATH"]
+
+# check for valid parameters
+validate_parameters $platform, $browser_type, $app_path
+
+# If platform is android or ios create driver instance for mobile browser
+if $platform == "android" or $platform == "iOS"
+  if $browser_type == "native"
+    $browser_type = "Browser"
+  end
+
+  if $platform == "android"
+    $device_name, $os_version = get_device_info
+  end
+
+  # desired_caps = {
+  #   caps:       {
+  #     platformName: $platform,
+  #     browserName: $browser_type,
+  #     versionNumber: $os_version,
+  #     deviceName: $device_name,
+  #     udid: $udid,
+  #     app: ".//#{$app_path}"
+  #     }
+  #   }
+  #   appium_url = 'http://localhost:4723/wd/hub'
+  #   opts = {
+  #   desired_capabilities: { # or { caps: {....} }
+  #     platformName: :android,
+  #     deviceName: 'Android Simulator',
+  #     app: "WikipediaSample.apk"
+  #   },
+  #   appium_lib: {
+  #     wait: 30
+  #   }
+  # }
+
+  opts = {
+    desired_capabilities: { # or { caps: {....} }
+      platformName: $platform,
+      browserName: $browser_type,
+      deviceName: $device_name,
+      versionNumber: $os_version,
+      app: "WikipediaSample.apk",
+    },
+    appium_lib: {
+      wait: 30,
+    },
+  }
+
+  begin
+    # $driver = Appium::Driver.new(desired_caps, url: appium_url).start_driver
+
+    # $driver = Selenium::WebDriver.for(:remote, :url => appium_url, :desired_capabilities => desired_caps)
+    @core = Appium::Core.for(opts) # create a core driver with `opts`
+    $driver = @core.start_driver
+  rescue Exception => e
+    puts e.message
+    Process.exit(0)
+  end
+else # else create driver instance for desktop browser
+  begin
+    $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"] = ENV["ENABLE_VNC"] if ENV["ENABLE_VNC"].present?
+          caps["enableVideo"] = ENV["ENABLE_VIDEO"] if ENV["ENABLE_VIDEO"].present?
+          caps["screenResolution"] = ENV["SCREEN_RESOLUTION"] if ENV["SCREEN_RESOLUTION"].present?
+          Selenium::WebDriver.for(:remote, :url => ENV["SERVER_URL"], :desired_capabilities => caps)
+        end
+      else
+        Selenium::WebDriver.for(:firefox)
+      end
+    $driver.manage().window().maximize()
+  rescue Exception => e
+    puts e.message
+    Process.exit(0)
+  end
+end

data/features-skeleton/support/hooks.rb

@@ -0,0 +1,38 @@
+def validate_params_exist
+  raise "❌  ERROR: Missing param SERVER_URL." if ENV['SERVER_URL'].nil?
+  raise "❌  ERROR: Missing param BROWSER." if ENV['BROWSER'].nil?
+  if ENV['REPORT']
+    raise "❌  ERROR: Missing param TESTSUITE." if ENV['TESTSUITE'].nil?
+    raise "❌  ERROR: Missing param TESTCASE_REPORT_NAME." if ENV['TESTCASE_REPORT_NAME'].nil?
+    $report_path = "Reports/#{ENV['TESTSUITE']}"
+    $testcase_report_name = ENV['TESTCASE_REPORT_NAME']
+  end
+end
+
+at_exit do
+  # quite driver
+  $driver.close()
+  if ENV['REPORT']
+    begin
+      # validateReport
+      time = Time.now.getutc
+      ReportBuilder.configure do |config|
+        config.report_path = "#{$report_path}/#{$testcase_report_name}"
+        config.input_path = "#{$report_path}/#{$testcase_report_name}.json"
+        config.report_types = [:json, :html]
+        config.color = 'blue'
+        config.additional_info = {
+          'Browser' => $browser_type,
+          'Platform' => $platform ,
+          'OS Version' => $os_version,
+          'Report Generated' => time
+        }
+      end
+      options = { report_title: "INFODation - Test Management System" }
+      ReportBuilder.build_report options
+    rescue Exception => e
+      puts e.message
+      Process.exit( 0 )
+    end
+  end
+end

data/lib/itms_automation.rb

@@ -1,3 +1 @@
-require 'cucumber_priority'
-require "itms_automation/version"
-Dir[File.dirname(__FILE__) + '/itms_automation/*.rb'].each { |file| require file }
+Dir[File.dirname(__FILE__) + '/itms_automation/methods/*.rb'].each { |file| require file }

data/lib/itms_automation/assertion_steps.rb

@@ -0,0 +1,68 @@
+# require 'cucumber'
+# require_relative 'methods/assertion_methods'
+
+# # page title checking
+# Then(/^I should\s*((?:not)?)\s+see page title as "(.*?)"$/) do |present, title|
+#   check_title(title, present.empty?)
+# end
+
+# Then(/^I should\s*((?:not)?)\s+see page title having partial text as "(.*?)"$/) do |present, partial_text_title|
+#   check_partial_title(partial_text_title, present.empty?)
+# end
+
+# # step to check element text
+# Then(/^element "([^\"]*)" should\s*((?:not)?)\s+have text as "(.*?)"$/) do |element, present, value |
+#   check_element_text(element, value, present.empty?)
+# end
+
+# # step to check element partial text
+# Then(/^element "([^\"]*)" should\s*((?:not)?)\s+have partial text as "(.*?)"$/) do |element, present, value |
+#   check_element_partial_text(element, value, present.empty?)
+# end
+
+# # step to check attribute value
+# Then(/^element "([^\"]*)" should\s*((?:not)?)\s+have attribute "(.*?)" with value "(.*?)"$/) do |element, present, attrb, value|
+#   check_element_attribute(element, attrb, value, present.empty?)
+# end
+
+# # step to check element enabled or not
+# Then(/^element "([^\"]*)" should\s*((?:not)?)\s+be (enabled|disabled)$/) do |element, present, state|
+#   flag = state == 'enabled'
+#   flag = !flag unless present.empty?
+#   check_element_enable(element, flag)
+# end
+
+# # step to check element present or not
+# Then(/^element "(.*?)" should\s*((?:not)?)\s+be present$/) do |element, present|
+#   check_element_presence(element, present.empty?)
+# end
+
+# # step to assert checkbox is checked or unchecked
+# Then(/^checkbox "(.*?)" should be (checked|unchecked)$/) do |element, state|
+#   flag = state == 'checked'
+#   is_checkbox_checked(element, flag)
+# end
+
+# # steps to assert radio button checked or unchecked
+# Then(/^radio button"(.*?)" should be (selected|unselected)$/) do |element, state|
+#   flag = state == 'selected'
+#   is_radio_button_selected(element, flag)
+# end
+
+# # steps to assert option by text from radio button group selected/unselected
+# Then(/^option "(.*?)" by (.+) from radio button group "(.*?)" should be (selected|unselected)$/) do |option, attrb, element, state|
+#   flag = state == 'selected'
+#   is_option_from_radio_button_group_selected(element, attrb, option, flag)
+# end
+
+# # step to assert javascript pop-up alert text
+# Then(/^I should see alert text as "(.*?)"$/) do |actual_value|
+#   check_alert_text(actual_value)
+# end
+
+# # step to assert dropdown list
+# Then(/^option "(.*?)" by (.+) from dropdown "(.*?)" should be (selected|unselected)$/) do |option, by, element, state|
+#   flag = state == 'selected'
+#   is_option_from_dropdown_selected(element, by, option, state)
+# end
+

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,333 @@
+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 : String
+def get_element_text(element)
+  WAIT.until { find_object(element) }.text
+end
+
+# Method to check element text
+# 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)
+
+  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
+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
+end
+
+# Method to return element status - enabled?
+# param : String : Element
+def is_element_enabled(element)
+  WAIT.until{ find_object(element) }.enabled?
+end
+
+# Element enabled checking
+# param 1 : String : Element
+# param 2 : 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 : Element
+# param 2 : 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 : 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)
+
+  attr_val = get_element_attribute(element, attribute_name)
+
+  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
+end
+
+# method to get element status - displayed?
+# param : String : Element
+def is_element_displayed(element)
+  WAIT.until{ find_object(element) }.displayed?
+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
+  end
+end
+
+# method to assert checkbox check/uncheck
+# 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
+end
+
+# method to assert radio button selected/unselected
+# 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
+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. Actual Value :#{get_alert_text}"
+  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