selenium-cucumber 2.1.4 → 3.1.4

data/lib/selenium-cucumber.rb

@@ -1 +1 @@
-Dir[File.dirname(__FILE__) + '/selenium-cucumber/*.rb'].each { |file| require file }
+Dir[File.dirname(__FILE__) + '/selenium-cucumber/*.rb'].each { |file| require file }

data/lib/selenium-cucumber/assertion_steps.rb

@@ -1,89 +1,89 @@
-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 having (.+) "([^\"]*)" should\s*((?:not)?)\s+have text as "(.*?)"$/) do |type, access_name, present, value |
-  validate_locator type
-  check_element_text(type, value, access_name, present.empty?)
-end
-
-# step to check element partial text
-Then(/^element having (.+) "([^\"]*)" should\s*((?:not)?)\s+have partial text as "(.*?)"$/) do |type, access_name, present, value |
-  validate_locator type
-  check_element_partial_text(type, value, access_name, present.empty?)
-end
-
-# step to check attribute value
-Then(/^element having (.+) "([^\"]*)" should\s*((?:not)?)\s+have attribute "(.*?)" with value "(.*?)"$/) do |type, access_name, present, attrb, value|
-  validate_locator type
-  check_element_attribute(type, attrb, value, access_name, present.empty?)
-end
-
-# step to check element enabled or not
-Then(/^element having (.+) "([^\"]*)" should\s*((?:not)?)\s+be (enabled|disabled)$/) do |type, access_name, present, state|
-  validate_locator type
-  flag = state == 'enabled'
-  flag = !flag unless present.empty?
-  check_element_enable(type, access_name, flag)
-end
-
-# step to check element present or not
-Then(/^element having (.+) "(.*?)" should\s*((?:not)?)\s+be present$/) do |type, access_name, present|
-  validate_locator type
-  check_element_presence(type, access_name, present.empty?)
-end
-
-# step to assert checkbox is checked or unchecked
-Then(/^checkbox having (.+) "(.*?)" should be (checked|unchecked)$/) do |type, access_name, state|
-  validate_locator type
-  flag = state == 'checked'
-  is_checkbox_checked(type, access_name, flag)
-end
-
-# steps to assert radio button checked or unchecked
-Then(/^radio button having (.+) "(.*?)" should be (selected|unselected)$/) do |type, access_name, state|
-  validate_locator type
-  flag = state == 'selected'
-  is_radio_button_selected(type, access_name, flag)
-end
-
-# steps to assert option by text from radio button group selected/unselected
-Then(/^option "(.*?)" by (.+) from radio button group having (.+) "(.*?)" should be (selected|unselected)$/) do |option, attrb, type, access_name, state|
-  validate_locator type
-  flag = state == 'selected'
-  is_option_from_radio_button_group_selected(type, attrb, option, access_name, flag)
-end
-
-# steps to check link presence
-Then(/^link having text "(.*?)" should\s*((?:not)?)\s+be present$/) do |access_name, present|
-  check_element_presence('link', access_name, present.empty?)
-end
-
-Then(/^link having partial text "(.*?)" should\s*((?:not)?)\s+be present$/) do |access_name, present|
-  check_element_presence('partial_link_text', access_name, present.empty?)
-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 having (.+) "(.*?)" should be (selected|unselected)$/) do |option, by, type, access_name, state|
-  validate_locator type
-  flag = state == 'selected'
-  is_option_from_dropdown_selected(type, by, option, access_name, state)
-end
-
-# step to assert difference in images
-Then(/^actual image having (.+) "(.*?)" and expected image having (.+) "(.*?)" should be similar$/) do |actual_img_access_type, actual_img_access_name, excp_img_access_type, excp_img_access_name|
-  does_images_similar?(actual_img_access_type, actual_img_access_name, excp_img_access_type, excp_img_access_name)
-end
+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 having (.+) "([^\"]*)" should\s*((?:not)?)\s+have text as "(.*?)"$/) do |type, access_name, present, value |
+  validate_locator type
+  check_element_text(type, value, access_name, present.empty?)
+end
+
+# step to check element partial text
+Then(/^element having (.+) "([^\"]*)" should\s*((?:not)?)\s+have partial text as "(.*?)"$/) do |type, access_name, present, value |
+  validate_locator type
+  check_element_partial_text(type, value, access_name, present.empty?)
+end
+
+# step to check attribute value
+Then(/^element having (.+) "([^\"]*)" should\s*((?:not)?)\s+have attribute "(.*?)" with value "(.*?)"$/) do |type, access_name, present, attrb, value|
+  validate_locator type
+  check_element_attribute(type, attrb, value, access_name, present.empty?)
+end
+
+# step to check element enabled or not
+Then(/^element having (.+) "([^\"]*)" should\s*((?:not)?)\s+be (enabled|disabled)$/) do |type, access_name, present, state|
+  validate_locator type
+  flag = state == 'enabled'
+  flag = !flag unless present.empty?
+  check_element_enable(type, access_name, flag)
+end
+
+# step to check element present or not
+Then(/^element having (.+) "(.*?)" should\s*((?:not)?)\s+be present$/) do |type, access_name, present|
+  validate_locator type
+  check_element_presence(type, access_name, present.empty?)
+end
+
+# step to assert checkbox is checked or unchecked
+Then(/^checkbox having (.+) "(.*?)" should be (checked|unchecked)$/) do |type, access_name, state|
+  validate_locator type
+  flag = state == 'checked'
+  is_checkbox_checked(type, access_name, flag)
+end
+
+# steps to assert radio button checked or unchecked
+Then(/^radio button having (.+) "(.*?)" should be (selected|unselected)$/) do |type, access_name, state|
+  validate_locator type
+  flag = state == 'selected'
+  is_radio_button_selected(type, access_name, flag)
+end
+
+# steps to assert option by text from radio button group selected/unselected
+Then(/^option "(.*?)" by (.+) from radio button group having (.+) "(.*?)" should be (selected|unselected)$/) do |option, attrb, type, access_name, state|
+  validate_locator type
+  flag = state == 'selected'
+  is_option_from_radio_button_group_selected(type, attrb, option, access_name, flag)
+end
+
+# steps to check link presence
+Then(/^link having text "(.*?)" should\s*((?:not)?)\s+be present$/) do |access_name, present|
+  check_element_presence('link', access_name, present.empty?)
+end
+
+Then(/^link having partial text "(.*?)" should\s*((?:not)?)\s+be present$/) do |access_name, present|
+  check_element_presence('partial_link_text', access_name, present.empty?)
+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 having (.+) "(.*?)" should be (selected|unselected)$/) do |option, by, type, access_name, state|
+  validate_locator type
+  flag = state == 'selected'
+  is_option_from_dropdown_selected(type, by, option, access_name, state)
+end
+
+# step to assert difference in images
+Then(/^actual image having (.+) "(.*?)" and expected image having (.+) "(.*?)" should be similar$/) do |actual_img_access_type, actual_img_access_name, excp_img_access_type, excp_img_access_name|
+  does_images_similar?(actual_img_access_type, actual_img_access_name, excp_img_access_type, excp_img_access_name)
+end

data/lib/selenium-cucumber/click_elements_steps.rb

@@ -1,36 +1,36 @@
-require_relative 'methods/click_elements_methods'
-
-# click on web element
-When(/^I click on element having (.+) "(.*?)"$/) do |type, access_name|
-  validate_locator type
-  click(type, access_name)
-end
-
-Then(/^I forcefully click on element having (.+) "(.*?)"$/) do |type, access_name|
-  validate_locator type
-  click_forcefully(type, access_name)
-end
-
-# double click on web element
-Then(/^I double click on element having (.+) "(.*?)"$/) do |type, access_value|
-  validate_locator type
-  double_click(type, access_value)
-end
-
-# steps to click on link
-Then(/^I click on link having text "(.*?)"$/) do |access_name|
-  click('link', access_name)
-end
-
-Then(/^I click on link having partial text "(.*?)"$/) do |access_name|
-  click('partial_link_text', access_name)
-end
-
-When(/^I tap on element having (.+) "(.*?)"$/) do |type, access_name|
-  validate_locator type
-  click(type, access_name)
-end
-
-
-
-
+require_relative 'methods/click_elements_methods'
+
+# click on web element
+When(/^I click on element having (.+) "(.*?)"$/) do |type, access_name|
+  validate_locator type
+  click(type, access_name)
+end
+
+Then(/^I forcefully click on element having (.+) "(.*?)"$/) do |type, access_name|
+  validate_locator type
+  click_forcefully(type, access_name)
+end
+
+# double click on web element
+Then(/^I double click on element having (.+) "(.*?)"$/) do |type, access_value|
+  validate_locator type
+  double_click(type, access_value)
+end
+
+# steps to click on link
+Then(/^I click on link having text "(.*?)"$/) do |access_name|
+  click('link', access_name)
+end
+
+Then(/^I click on link having partial text "(.*?)"$/) do |access_name|
+  click('partial_link_text', access_name)
+end
+
+When(/^I tap on element having (.+) "(.*?)"$/) do |type, access_name|
+  validate_locator type
+  click(type, access_name)
+end
+
+
+
+

data/lib/selenium-cucumber/configuration_steps.rb

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

data/lib/selenium-cucumber/input_steps.rb

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

data/lib/selenium-cucumber/javascript_handling_steps.rb

@@ -1,9 +1,9 @@
-require_relative 'methods/javascript_handling_methods'
-
-Then(/^I accept alert$/) do
-  handle_alert('accept')
-end
-
-Then(/^I dismiss alert$/) do
-  handle_alert('dismiss')
-end
+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/selenium-cucumber/methods/assertion_methods.rb

@@ -1,344 +1,295 @@
-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}, Expected Page Title : #{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(access_type, access_name)
-  WAIT.until { $driver.find_element(:"#{access_type}" => "#{access_name}") }.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(access_type, expected_value, access_name, test_case)
-  element_text = get_element_text(access_type, access_name)
-
-  if test_case
-    if element_text != expected_value
-      raise TestCaseFailed, "Text Not Matched, Actual Text : #{element_text}, Expected Text : #{expected_value}"
-    end
-  else
-    if element_text == expected_value
-      raise TestCaseFailed, "Text Matched, Actual Text : #{element_text}"
-    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(access_type, expected_value, access_name, test_case)
-  element_text = get_element_text(access_type, access_name)
-
-  if test_case
-    if not element_text.include? "#{expected_value}"
-      raise TestCaseFailed, "Element text : #{element_text}, does not contains partial text as : #{expected_value}"
-    end
-  else
-    if element_text.include? "#{expected_value}"
-      raise TestCaseFailed, "Element text : #{element_text}, contains partial text as : #{expected_value}"
-    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(access_type, access_name)
-  WAIT.until{ $driver.find_element(:"#{access_type}" => "#{access_name}") }.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(access_type, access_name, test_case)
-  result = is_element_enabled(access_type, access_name)
-
-  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(access_type, access_name, attribute_name)
-  WAIT.until{ $driver.find_element(:"#{access_type}" => "#{access_name}") }.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(access_type, attribute_name, attribute_value, access_name, test_case)
-
-  attr_val = get_element_attribute(access_type, access_name, attribute_name)
-
-  if test_case
-    if attr_val != attribute_value
-      raise TestCaseFailed, "Attribute Value Not Matched, Actual Value : #{attr_val}, Expected Value : #{attribute_value}"
-    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 1 : String : Locator type (id, name, class, xpath, css)
-# param 2 : String : Locator value
-def is_element_displayed(access_type, access_name)
-  WAIT.until{ $driver.find_element(:"#{access_type}" => "#{access_name}") }.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(access_type, access_name, test_case)
-  if test_case
-    if !is_element_displayed(access_type, access_name)
-      raise TestCaseFailed, 'Element Not Present'
-    end
-  else
-    begin
-      if is_element_displayed(access_type, access_name)
-        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(access_type, access_name, should_be_checked = true)
-  checkbox = WAIT.until{ $driver.find_element(:"#{access_type}" => "#{access_name}") }
-
-  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(access_type, access_name, should_be_selected = true)
-  radio_button = WAIT.until{ $driver.find_element(:"#{access_type}" => "#{access_name}") }
-
-  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(access_type, by, option, access_name, should_be_selected = true)
-  radio_button_group = WAIT.until{ $driver.find_elements(:"#{access_type}" => "#{access_name}") }
-
-  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 Text : #{get_alert_text}, Expected Text : #{text}"
-  end
-end
-
-def is_option_from_dropdown_selected(access_type, by, option, access_name, should_be_selected=true)
-  dropdown = WAIT.until { $driver.find_element(:"#{access_type}" => "#{access_name}") }
-  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
+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
+    expect(page_title).to eq title
+  else
+    expect(page_title).to_not eq title
+  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
+    expect(page_title).to include(partial_text_title)
+  else
+    expect(page_title).to_not include(partial_text_title)
+  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(access_type, access_name)
+  $driver.find_element(:"#{access_type}" => "#{access_name}").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(access_type, expected_value, access_name, test_case)
+  element_text = get_element_text(access_type, access_name)
+  if test_case
+    expect(element_text).to eq expected_value
+  else
+    expect(element_text).to_not eq expected_value
+  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(access_type, expected_value, access_name, test_case)
+  element_text = get_element_text(access_type, access_name)
+
+  if test_case
+    expect(element_text).to include(expected_value)
+  else
+    expect(element_text).to_not include(expected_value)
+  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(access_type, access_name)
+  $driver.find_element(:"#{access_type}" => "#{access_name}").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(access_type, access_name, test_case)
+  result = is_element_enabled(access_type, access_name)
+  if test_case
+    expect(result).to be true
+  else
+    expect(result).to be false
+  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(access_type, access_name, attribute_name)
+  $driver.find_element(:"#{access_type}" => "#{access_name}").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(access_type, attribute_name, attribute_value, access_name, test_case)
+
+  attr_val = get_element_attribute(access_type, access_name, attribute_name)
+
+  if test_case
+    expect(attr_val).to eq(attribute_value)
+  else
+    expect(attr_val).to_not eq(attribute_value)
+  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)
+  begin
+    $driver.find_element(:"#{access_type}" => "#{access_name}").displayed?
+  rescue Selenium::WebDriver::Error::NoSuchElementError
+    # elements not found return false
+    false
+  end
+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(access_type, access_name, test_case)
+  expect(is_element_displayed(access_type, access_name)).to be test_case
+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(access_type, access_name, should_be_checked = true)
+  checkbox = $driver.find_element(:"#{access_type}" => "#{access_name}")
+
+  expect(checkbox.selected?).to be should_be_checked
+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(access_type, access_name, should_be_selected = true)
+  radio_button = $driver.find_element(:"#{access_type}" => "#{access_name}")
+  expect(radio_button.selected?).to be should_be_selected
+end
+
+# method to assert option from radio button group is selected/unselected
+def is_option_from_radio_button_group_selected(access_type, by, option, access_name, should_be_selected = true)
+  radio_button_group = $driver.find_elements(:"#{access_type}" => "#{access_name}")
+
+  getter = ->(rb, by) { by == 'value' ? rb.attribute('value') : rb.text }
+
+  ele = radio_button_group.find { |rb| getter.call(rb, by) == option }
+
+  expect(ele.selected?).to be should_be_selected
+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)
+  expect(get_alert_text).to eq text
+end
+
+def is_option_from_dropdown_selected(access_type, by, option, access_name, should_be_selected=true)
+  dropdown = $driver.find_element(:"#{access_type}" => "#{access_name}")
+  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
+  expect(actual_value).to eq option 
+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