itms_automation 2.6.7 → 2.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d444bed9e0cfd7a8c172326b6fb3ec89e6c7b1e35caa8937dbb08d5e2c642bbc
-  data.tar.gz: 0c744a217e2790acf13691eaf2d219172863e110b2a81877feb59b8b17903714
+  metadata.gz: 8113d92ae42388d312d06addf7983729e8c339394101e42e5bf7696b157159ba
+  data.tar.gz: 99c7336da205831dad925b554d538992031423b5d712c10722482708ad96075b
 SHA512:
-  metadata.gz: a6620750cdedf9b304e4ea53ebda419b5ac383f6999261b9c7acee0d44921d50a3e1ddc31b841aa4b54abf2860b1bbdb3bfb2aa5b6d39ec989bfd2eee8024cbc
-  data.tar.gz: c7673be15169b7371e41bcb15572f042b2a70a4aa1732fdd776fd1f49c7ff1aa8608fd18cce5eb74b654f2a152580e06913625165170fbdc93906a994f269c73
+  metadata.gz: f5705b378186e404e89587da1b64d5b05dedbd3289120b73a209daef2598c2b5d4ce6055b007654be5fa38255ea098a6f145fa7bc4703c8846bd4cd3cbbf2099
+  data.tar.gz: 6d8065f8be72393b605c9135c923a259fcbbdeab9e1fec1b71bd0a4137a9cdca846cbfa63b81526679bd9349e5cffb26b28e57c79125e0ac47c5cae5ee836f7f

data/doc/installation.md

@@ -2,7 +2,7 @@ Installation
 ============
 ### Prerequisites
 You need to have Ruby installed.
-Verify your installation by running ruby -v in a terminal - it should print "ruby 1.9.3" (or higher).
+Verify your installation by running ruby -v in a terminal - it should print "ruby 2.0.0" (or higher).
 
 You need to have DevKit installed.
 

data/features-skeleton/my_first.feature

@@ -1,10 +1,19 @@
-# 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
+# Feature: Login Functionality
+#     In order to ensure login functionality works,
+#     I want to run the cucumber test to verify it is working
+
+#     Background:
+#         Given the login page is opened successfully
+
+#     Scenario: Login Valid
+#         When user input username "tomsmith" and password "SuperSecretPassword!"
+#         Then the message "You logged into a secure area!×" should be displayed
+
+#     Scenario Outline: Login Invalid
+#         When user input username "<username>" and password "<password>"
+#         Then the message "<messsage>" should be displayed
+
+#         Examples:
+#             | username | password             | messsage                   |
+#             | anhpham  | SuperSecretPassword! | Your username is invalid!× |
+#             | tomsmith | wrong_password       | Your password is invalid!× |

data/features-skeleton/step_definitions/input_steps.rb

@@ -4,12 +4,12 @@
 
 # # enter text into input field steps
 # Then(/^I enter "([^\"]*)" into element "(.*?)"$/) do |text, element|
-#   enter_text(type, element)
+#   enter_text(element, text)
 # end
 
 # # clear input field steps
-# Then(/^I clear input element "(.*?)"$/) do |type, element|
-#   clear_text(type, element)
+# Then(/^I clear input element "(.*?)"$/) do |element|
+#   clear_text(element)
 # end
 
 # # select option by text/value from dropdown/multiselect

data/features-skeleton/step_definitions/my_first_steps.rb

@@ -0,0 +1,14 @@
+# Given('the login page is opened successfully') do
+#     $driver.get("http://the-internet.herokuapp.com/login")
+# end
+
+# When('user input username {string} and password {string}') do |string, string2|
+#     $driver.find_element(:id, 'username').send_keys(string)
+#     $driver.find_element(:id, 'password').send_keys(string2)
+#     $driver.find_element(:css, '[class="fa fa-2x fa-sign-in"]').click
+# end
+
+# Then('the message {string} should be displayed') do |string|
+#     message = $driver.find_element(:css, '#flash').text.delete("\n")
+#     expect(message).to eql(string)
+# end

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

@@ -1 +1 @@
-button: { id: 'submit' }
+test_object: {id: 'username'}

data/features-skeleton/support/env.rb

@@ -1,78 +1,14 @@
 require "rubygems"
 require "itms_automation"
 require "httparty"
-require "cucumber"
 require "report_builder"
-require "selenium-webdriver"
+require "webdrivers"
 
 $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
+begin
+  $vars = {}
+  $driver = case $browser_type
     when "chrome"
       Selenium::WebDriver.for(:chrome)
     when "safari"
@@ -82,29 +18,22 @@ else # else create driver instance for desktop browser
     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"
+      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
-        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"] = true
-          caps["enableVideo"] = true
-          caps["resolution"] = ENV["resolution"] unless ENV["resolution"]
-          Selenium::WebDriver.for(:remote, :url => ENV["SERVER_URL"], :desired_capabilities => caps)
+        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
-    $driver.manage().window().maximize()
-  rescue Exception => e
-    puts e.message
-    Process.exit(0)
+  else
+    Selenium::WebDriver.for(:firefox)
   end
+rescue Exception => e
+  puts e.message
+  Process.exit(0)
 end

data/lib/itms_automation/input_steps.rb

@@ -3,7 +3,7 @@
 
 # # enter text into input field steps
 # Then(/^I enter "([^\"]*)" into element "(.*?)"$/) do |text, element|
-#   enter_text(type, element)
+#   enter_text(element, text)
 # end
 
 # # clear input field steps

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
 
-  attr_val = get_element_attribute(element, attribute_name)
+def assert_prompt(text)
+  alert_text = $driver.switch_to.alert.text
+  expect(alert_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_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
 
-# method to get element status - displayed?
-# param : String : Element
-def is_element_displayed(element)
-  WAIT.until{ find_object(element) }.displayed?
+def assert_value(element, text)
+  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
-  end
+def assert_selected_value
+  found_element = find_object(element)
+  value = found_element.attribute("value")
+  expect(value).to eq(text)
 end
 
-# method to assert checkbox check/uncheck
+def assert(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 verify title
+# param 1: String : expected title
+def verify_title(title)
+  expect($driver.title).to eq(title)
+end
+
+# 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