selenium-cucumber 1.1.2 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d724e0e3ee3efebe417033b395869a70825c43e
-  data.tar.gz: 495d6949f5db99ebc87562ae86ec07934b9c2cab
+  metadata.gz: 06ba324f137c7beac5a434968028ac9c2d841a71
+  data.tar.gz: c0b17d8c1fc7e82d63a7fd65bf712f6fa3ccb2fc
 SHA512:
-  metadata.gz: 7017731725dc4ef15e1f550aaa8c757eaf208922330e914e2d5758e4412091120f2346a1179421bb64ee4f4289927fd07f411e7101a6c9d8337032ae10e644ea
-  data.tar.gz: ea90be96b6aac6e26d62dce92b5cda714e664cdb2ce4ed9cd3d0dcb6d76a8e44ed65c67a0888e9fd7fad89b2018292d63324c7911117a6d007a423c28604d183
+  metadata.gz: 8057e8b7d347b508832c14a95d9170f4b20446b1333e3e5d5422e2e16e46e15ee2427fa911f2e6001b0827d6f3142c95d5910efbfa87619201fba37374040fe6
+  data.tar.gz: a42178e44886762fba3784f45d66170cd439705dbc4fc628e626576814ff56369525f12f03a72814a3e513228268660e04b976455fd32dc5f16c738415f57bed

data/doc/canned_steps.md

@@ -20,6 +20,7 @@ To open/close URL and to navigate between pages use following steps :
 	Then I navigate back
 	Then I refresh page
 	Then I switch to new window
+	Then I close new window
 	Then I switch to previous window
 	
 To interact with browser use following steps :    
@@ -72,7 +73,11 @@ Assertion Steps
 To assert that page title can be found use following step :
 
 	Then I should see page title as "(.*?)"
+	Then I should not see page title as "(.*?)"
 
+	Then I should see page title having partial text as "(.*?)"
+    Then I should not see page title having partial text as "(.*?)"
+    
 #### Steps For Asserting Element Text
 
 To assert element text use any of the following steps :
@@ -520,3 +525,15 @@ Configuration Steps
 To print testing configuration use following step :
 
 	Then I print configuration
+
+#Mobile Steps
+
+##Tap Steps
+-----------
+To tap on app element use following steps :
+
+	Then I tap on element having id "(.*?)"
+	Then I tap on element having name "(.*?)"
+	Then I tap on element having class "(.*?)"
+	Then I tap on element having xpath "(.*?)"
+	Then I tap on element having css "(.*?)"	

data/features-skeleton/support/env.rb

@@ -1,38 +1,51 @@
 require 'rubygems'
-require 'selenium-webdriver'
+require 'selenium-cucumber'
 
-def print_error
-  puts "\nInappropraite browser \"#{ENV['BROWSER']}\""
-  puts "\nUsage : cucumber BROWSER=browser_name"
-  puts "\nbrowser_name can be one of following :"
-  puts "1.ie\n2.chrome\n3.ff\n4.safari\n5.opera" 
-  puts "\nNow using default browser \"Firefox\""
-end
+# Store command line arguments
+$browser_type = ENV['BROWSER'] || 'ff'
+$platform = ENV['PLATFORM'] || 'desktop'
+$os_version = ENV['OS_VERSION']
+$device_name = ENV['DEVICE_NAME']
+$udid = ENV['UDID']
+$app_path = ENV['APP_PATH']
 
-case ENV['BROWSER']
-  when 'ie'
-    browser_type = :ie
-  when 'ff'
-    browser_type = :ff
-  when 'chrome'
-    browser_type = :chrome
-  when 'opera'
-    browser_type = :opera
-  when 'safari'
-    browser_type = :safari
-  else
-    if ENV['BROWSER']
-      print_error
-    end
-    browser_type = :ff
-end
+# 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}"
+      },
+    }
 
-begin
-    $driver = Selenium::WebDriver.for(browser_type)
+  begin
+    $driver = Appium::Driver.new(desired_caps).start_driver
+  rescue Exception => e
+    puts e.message
+    Process.exit(0)  
+  end
+else # else create driver instance for desktop browser
+  begin
+    $driver = Selenium::WebDriver.for(:"#{$browser_type}")
     $driver.manage().window().maximize()
-
   rescue Exception => e
     puts e.message
+    Process.exit(0)
+  end
 end
-

data/lib/selenium-cucumber.rb

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

data/lib/selenium-cucumber/assertion_steps.rb

@@ -1,8 +1,12 @@
 require_relative 'methods/assertion_methods'
 
 # page title checking
-Then(/^I should see page title as "(.*?)"$/) do |title|
-  check_title(title)
+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

data/lib/selenium-cucumber/click_elements_steps.rb

@@ -25,3 +25,13 @@ 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
+
+Then(/^I long press on element having (.+) "(.*?)"$/) do |type, access_name|
+  validate_locator type
+  long_press(type, access_name, duration)
+end

data/lib/selenium-cucumber/methods/assertion_methods.rb

@@ -1,21 +1,57 @@
 require 'net/https'
 require_relative 'required_files'
 
-# Page title checking
+# This file contains assertion methods which are called from assertion_steps.rb
+
+# Method to return page title
 def get_page_title
   $driver.title
 end
 
-def check_title(title)
-  raise TestCaseFailed, 'Page Title Not Matched' unless get_page_title == title
+# 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(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, actual_value, access_name, test_case)
   element_text = get_element_text(access_type, access_name)
 
@@ -31,6 +67,10 @@ def check_element_text(access_type, actual_value, access_name, test_case)
 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, actual_value, access_name, test_case)
   element_text = get_element_text(access_type, access_name)
 
@@ -46,11 +86,16 @@ def check_element_partial_text(access_type, actual_value, access_name, test_case
 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)
 
@@ -62,11 +107,19 @@ def check_element_enable(access_type, access_name, test_case)
 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)
@@ -83,11 +136,16 @@ def check_element_attribute(access_type, attribute_name, attribute_value, access
 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)
@@ -96,10 +154,10 @@ def check_element_presence(access_type, access_name, test_case)
   else
     begin
       if is_element_displayed(access_type, access_name)
-        raise 'Present'
+        raise 'Present' # since it is negative test and we found element
       end
     rescue Exception => e
-      if e.message == 'Present'
+      if e.message == 'Present' # only raise if it present
         raise TestCaseFailed, 'Element Present'
       end
     end
@@ -107,6 +165,9 @@ def check_element_presence(access_type, access_name, 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 = WAIT.until{ $driver.find_element(:"#{access_type}" => "#{access_name}") }
 
@@ -118,6 +179,9 @@ def is_checkbox_checked(access_type, access_name, should_be_checked = true)
 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}") }
 
@@ -180,6 +244,10 @@ def does_images_similar?(actual_img_access_type, actual_img_access_name, excp_im
 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
@@ -195,10 +263,12 @@ def compare_image(actual_img_access_type, actual_img_access_name, excp_img_acces
     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
@@ -209,14 +279,14 @@ def compare_image(actual_img_access_type, actual_img_access_name, excp_img_acces
     image_type = 'jpg'
   end
 
-# Storing actual image locally
+  # 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
+  # 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
@@ -224,7 +294,7 @@ def compare_image(actual_img_access_type, actual_img_access_name, excp_img_acces
     expected_img_url = './features/expected_images/expected_image.' + image_type
   end
 
-# Verify image extension and call respective compare function
+  # Verify image extension and call respective compare function
   if image_type == 'png'
     return compare_png_images(expected_img_url, actual_img_url)
   end

data/lib/selenium-cucumber/methods/click_elements_methods.rb

@@ -17,3 +17,11 @@ end
 def submit(access_type, access_name)
   WAIT.until { $driver.find_element(:"#{access_type}" => "#{access_name}") }.submit
 end
+
+def long_press(type, access_name, duration)
+  element = WAIT.until { $driver.find_element(:"#{access_type}" => "#{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

data/lib/selenium-cucumber/methods/configuration_methods.rb

@@ -1,14 +1,35 @@
 require_relative 'required_files'
 
 # method to print configuration
-
 def print_congifugartion
   puts ''
   puts "Date : #{Time.now.strftime("%d-%B-%Y")}"
   puts "Time : #{Time.now.strftime("%I:%M:%S:%p")}"
-  puts 'Operating System : ' + Selenium::WebDriver::Platform.os.to_s.upcase
+
+  if $platform == 'android' or $platform == 'ios'
+  	print_mobile_configuration
+  else
+  	print_desktop_configuration
+  end
+end
+
+# method to print desktop configuration
+def print_desktop_configuration
+  puts 'Platform : ' + Selenium::WebDriver::Platform.os.to_s.upcase
   puts 'Browser : ' + $driver.capabilities.browser_name.to_s.upcase + " " + $driver.capabilities.version.to_s
   puts ''
 end
 
+# method to print mobile configuration
+def print_mobile_configuration
+  puts "Platform : #{$platform.upcase}" 
+  puts "OS version : #{$os_version}" 
+  puts "Device : #{$device_name}" 
 
+  if $app_path.nil?
+  	puts 'Browser : ' + $driver.capabilities.browser_name.to_s.upcase + " " + $driver.capabilities.version.to_s
+  else
+  	puts "App Tested : #{$app_path}" 
+  end
+  puts ''
+end

data/lib/selenium-cucumber/methods/error_handling_methods.rb

@@ -0,0 +1,87 @@
+# Error handling methods
+
+# Method to check browser type
+def validate_parameters(platform, browser_type, app_path)
+  if platform == 'desktop'
+    if !%w(ff ie chrome safari opera).include? browser_type
+      print_error_desktop
+    end
+  elsif platform == 'android'
+      print_error_android browser_type, app_path
+  elsif platform == 'iOS'
+    puts "Not Implemented..."
+    # print_error_ios browser_type, app_path
+  else
+    print_invalid_platform
+  end
+end
+
+# print error for desktop
+def print_error_desktop
+  puts "\nInappropraite desktop browser : \"#{ENV['BROWSER']}\""
+  puts "\nUsage : cucumber BROWSER=browser_name"
+  puts "\nBrowser Supported  :\n"
+  puts "\n1.ie\n2.chrome\n3.ff\n4.safari\n5.opera"
+  Process.exit(0) 
+end
+
+# print error for android
+def print_error_android(browser_type, app_path)
+  if browser_type=='ff' and app_path==nil
+    puts "\nOops... not mentioned \"Browser\" or \"App path\""
+    print_error_android_app
+    print_error_android_web
+    Process.exit(0) 
+  elsif browser_type!='ff' and !%w(native chrome).include? browser_type
+    puts "\nOops... not supported browser"
+    print_error_android_web
+    Process.exit(0) 
+  end
+end
+
+# print error for android app
+def print_error_android_app
+  puts "\nTo run test on android app"
+  puts "\n  Usage : cucumber PLATFORM=android APP_PATH=path/to/app"
+end
+
+# print error for android web
+def print_error_android_web
+  puts "\nTo run test on android mobile web"
+  puts "\n  Usage : cucumber PLATFORM=android BROWSER=browser_name"
+  puts "\n  Supported browsers are \"chrome\" and \"native\""
+end
+
+# print error for ios
+def print_error_ios
+  if browser_type=='ff' and app_path==nil
+    puts "\nOops... not mentioned \"Browser\" or \"App path\""
+    print_error_ios_app
+    print_error_ios_web
+    Process.exit(0) 
+  elsif browser_type!='safari'
+    puts "\nOops... not supported browser"
+    print_error_ios_app_web
+    Process.exit(0) 
+  end
+end
+
+# print error for ios app
+def print_error_ios_app
+  puts "\nTo run test on iOS App"
+  puts "\n  Usage : cucumber PLATFORM=iOS APP_PATH=path/to/app"
+end
+
+# print error for ios web
+def print_error_ios_web
+  puts "\nTo run test on iOS mobile web"
+  puts "\n  Usage : cucumber PLATFORM=iOS BROWSER=safari"
+end
+
+# print error if invalid platform
+def print_invalid_platform
+  puts "\nOops... Invalid Platform"
+  puts "\nSupported platform are \"android\" and \"iOS\"."
+  puts "\nTo run on Desktop no need to mention platform."
+  Process.exit(0) 
+end