require 'erb'
require 'page-object/locator_generator'
module PageObject
#
# Contains the class level methods that are inserted into your page objects
# when you include the PageObject module. These methods will generate another
# set of methods that provide access to the elements on the web pages.
#
# @see PageObject::WatirPageObject for the watir implementation of the platform delegate
# @see PageObject::SeleniumPageObject for the selenium implementation of the platform delegate
#
module Accessors
#
# Set some values that can be used within the class. This is
# typically used to provide values that help build dynamic urls in
# the page_url method
#
# @param [Hash] the value to set the params
#
def params=(the_params)
@params = the_params
end
#
# Return the params that exist on this page class
#
def params
@params ||= {}
end
#
# Specify the url for the page. A call to this method will generate a
# 'goto' method to take you to the page.
#
# @param [String] the url for the page.
# @param [Symbol] a method name to call to get the url
#
def page_url(url)
define_method("goto") do
platform.navigate_to self.page_url_value
end
define_method('page_url_value') do
lookup = url.kind_of?(Symbol) ? self.send(url) : url
erb = ERB.new(%Q{#{lookup}})
merged_params = self.class.instance_variable_get("@merged_params")
params = merged_params ? merged_params : self.class.params
erb.result(binding)
end
end
alias_method :direct_url, :page_url
#
# Creates a method that waits the expected_title of a page to match the actual.
# @param [String] expected_title the literal expected title for the page
# @param [Regexp] expected_title the expected title pattern for the page
# @param [optional, Integer] timeout default value is nil - do not wait
# @return [boolean]
# @raise An exception if expected_title does not match actual title
#
# @example Specify 'Google' as the expected title of a page
# expected_title "Google"
# page.has_expected_title?
#
def wait_for_expected_title(expected_title, timeout=::PageObject.default_element_wait)
define_method("wait_for_expected_title?") do
error_message = lambda { "Expected title '#{expected_title}' instead of '#{title}'" }
has_expected_title = (expected_title === title)
wait_until(timeout, error_message.call) do
has_expected_title = (expected_title === title)
end unless has_expected_title
raise error_message.call unless has_expected_title
has_expected_title
end
end
#
# Creates a method that compares the expected_title of a page against the actual.
# @param [String] expected_title the literal expected title for the page
# @param [Regexp] expected_title the expected title pattern for the page
# @return [boolean]
# @raise An exception if expected_title does not match actual title
#
# @example Specify 'Google' as the expected title of a page
# expected_title "Google"
# page.has_expected_title?
#
def expected_title(expected_title)
define_method("has_expected_title?") do
page_title = title
has_expected_title = (expected_title === page_title)
raise "Expected title '#{expected_title}' instead of '#{page_title}'" unless has_expected_title
has_expected_title
end
end
#
# Creates a method that provides a way to initialize a page based upon an expected element.
# This is useful for pages that load dynamic content.
# @param [Symbol] the name given to the element in the declaration
# @param [optional, Integer] timeout default value is 5 seconds
# @return [boolean]
#
# @example Specify a text box named :address expected on the page within 10 seconds
# expected_element(:address, 10)
# page.has_expected_element?
#
def expected_element(element_name, timeout=::PageObject.default_element_wait)
define_method("has_expected_element?") do
self.respond_to? "#{element_name}_element" and self.send("#{element_name}_element").when_present timeout
end
end
#
# Creates a method that provides a way to initialize a page based upon an expected element to become visible.
# This is useful for pages that load dynamic content and might have hidden elements that are not shown.
# @param [Symbol] the name given to the element in the declaration
# @param [optional, Integer] timeout default value is 5 seconds
# @param [optional, boolean] also check that element to be visible if set to true
# @return [boolean]
#
# @example Specify a text box named :address expected on the page within 10 seconds
# expected_element_visible(:address, 10)
# page.has_expected_element_visible?
#
def expected_element_visible(element_name, timeout=::PageObject.default_element_wait, check_visible=false)
define_method("has_expected_element_visible?") do
self.respond_to? "#{element_name}_element" and self.send("#{element_name}_element").when_present timeout
self.respond_to? "#{element_name}_element" and self.send("#{element_name}_element").when_visible timeout
end
end
#
# Identify an element as existing within a frame . A frame parameter
# is passed to the block and must be passed to the other calls to PageObject.
# You can nest calls to in_frame by passing the frame to the next level.
#
# @example
# in_frame(:id => 'frame_id') do |frame|
# text_field(:first_name, :id => 'fname', :frame => frame)
# end
#
# @param [Hash] identifier how we find the frame. The valid keys are:
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :regexp => Watir only
# @param frame passed from a previous call to in_frame. Used to nest calls
# @param block that contains the calls to elements that exist inside the frame.
#
def in_frame(identifier, frame=nil, &block)
frame = frame.nil? ? [] : frame.dup
frame << {frame: identifier}
block.call(frame)
end
#
# Identify an element as existing within an iframe. A frame parameter
# is passed to the block and must be passed to the other calls to PageObject.
# You can nest calls to in_frame by passing the frame to the next level.
#
# @example
# in_iframe(:id => 'frame_id') do |frame|
# text_field(:first_name, :id => 'fname', :frame => frame)
# end
#
# @param [Hash] identifier how we find the frame. The valid keys are:
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :regexp => Watir only
# @param frame passed from a previous call to in_iframe. Used to nest calls
# @param block that contains the calls to elements that exist inside the iframe.
#
def in_iframe(identifier, frame=nil, &block)
frame = frame.nil? ? [] : frame.dup
frame << {iframe: identifier}
block.call(frame)
end
#
# adds four methods to the page object - one to set text in a text field,
# another to retrieve text from a text field, another to return the text
# field element, another to check the text field's existence.
#
# @example
# text_field(:first_name, :id => "first_name")
# # will generate 'first_name', 'first_name=', 'first_name_element',
# # 'first_name?' methods
#
# @param [String] the name used for the generated methods
# @param [Hash] identifier how we find a text field. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :label => Watir and Selenium
# * :name => Watir and Selenium
# * :text => Watir and Selenium
# * :title => Watir and Selenium
# * :value => Watir only
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def text_field(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'text_field_for', &block)
define_method(name) do
return platform.text_field_value_for identifier.clone unless block_given?
self.send("#{name}_element").value
end
define_method("#{name}=") do |value|
return platform.text_field_value_set(identifier.clone, value) unless block_given?
self.send("#{name}_element").value = value
end
end
#
# adds three methods to the page object - one to get the text from a hidden field,
# another to retrieve the hidden field element, and another to check the hidden
# field's existence.
#
# @example
# hidden_field(:user_id, :id => "user_identity")
# # will generate 'user_id', 'user_id_element' and 'user_id?' methods
#
# @param [String] the name used for the generated methods
# @param [Hash] identifier how we find a hidden field. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :text => Watir and Selenium
# * :value => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def hidden_field(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'hidden_field_for', &block)
define_method(name) do
return platform.hidden_field_value_for identifier.clone unless block_given?
self.send("#{name}_element").value
end
end
alias_method :hidden, :hidden_field
#
# adds four methods to the page object - one to set text in a text area,
# another to retrieve text from a text area, another to return the text
# area element, and another to check the text area's existence.
#
# @example
# text_area(:address, :id => "address")
# # will generate 'address', 'address=', 'address_element',
# # 'address?' methods
#
# @param [String] the name used for the generated methods
# @param [Hash] identifier how we find a text area. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# * :label => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def text_area(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'text_area_for', &block)
define_method(name) do
return platform.text_area_value_for identifier.clone unless block_given?
self.send("#{name}_element").value
end
define_method("#{name}=") do |value|
return platform.text_area_value_set(identifier.clone, value) unless block_given?
self.send("#{name}_element").value = value
end
end
alias_method :textarea, :text_area
#
# adds five methods - one to select an item in a drop-down,
# another to fetch the currently selected item text, another
# to retrieve the select list element, another to check the
# drop down's existence and another to get all the available options
# to select from.
#
# @example
# select_list(:state, :id => "state")
# # will generate 'state', 'state=', 'state_element', 'state?', "state_options" methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a select list. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :text => Watir only
# * :value => Watir only
# * :xpath => Watir and Selenium
# * :label => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def select_list(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'select_list_for', &block)
define_method(name) do
return platform.select_list_value_for identifier.clone unless block_given?
self.send("#{name}_element").value
end
define_method("#{name}=") do |value|
return platform.select_list_value_set(identifier.clone, value) unless block_given?
self.send("#{name}_element").select(value)
end
define_method("#{name}_options") do
element = self.send("#{name}_element")
(element && element.options) ? element.options.collect(&:text) : []
end
end
alias_method :select, :select_list
#
# adds three methods - one to select a link, another
# to return a PageObject::Elements::Link object representing
# the link, and another that checks the link's existence.
#
# @example
# link(:add_to_cart, :text => "Add to Cart")
# # will generate 'add_to_cart', 'add_to_cart_element', and 'add_to_cart?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a link. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :href => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :link => Watir and Selenium
# * :link_text => Watir and Selenium
# * :name => Watir and Selenium
# * :text => Watir and Selenium
# * :title => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def link(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'link_for', &block)
define_method(name) do
return platform.click_link_for identifier.clone unless block_given?
self.send("#{name}_element").click
end
end
alias_method :a, :link
#
# adds five methods - one to check, another to uncheck, another
# to return the state of a checkbox, another to return
# a PageObject::Elements::CheckBox object representing the checkbox, and
# a final method to check the checkbox's existence.
#
# @example
# checkbox(:active, :name => "is_active")
# # will generate 'check_active', 'uncheck_active', 'active_checked?',
# # 'active_element', and 'active?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a checkbox. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :value => Watir and Selenium
# * :xpath => Watir and Selenium
# * :label => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def checkbox(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'checkbox_for', &block)
define_method("check_#{name}") do
return platform.check_checkbox(identifier.clone) unless block_given?
self.send("#{name}_element").check
end
define_method("uncheck_#{name}") do
return platform.uncheck_checkbox(identifier.clone) unless block_given?
self.send("#{name}_element").uncheck
end
define_method("#{name}_checked?") do
return platform.checkbox_checked?(identifier.clone) unless block_given?
self.send("#{name}_element").checked?
end
end
#
# adds four methods - one to select, another to return if a radio button
# is selected, another method to return a PageObject::Elements::RadioButton
# object representing the radio button element, and another to check
# the radio button's existence.
#
# @example
# radio_button(:north, :id => "north")
# # will generate 'select_north', 'north_selected?',
# # 'north_element', and 'north?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a radio button. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :value => Watir and Selenium
# * :xpath => Watir and Selenium
# * :label => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def radio_button(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'radio_button_for', &block)
define_method("select_#{name}") do
return platform.select_radio(identifier.clone) unless block_given?
self.send("#{name}_element").select
end
define_method("#{name}_selected?") do
return platform.radio_selected?(identifier.clone) unless block_given?
self.send("#{name}_element").selected?
end
end
alias_method :radio, :radio_button
#
# adds five methods to help interact with a radio button group -
# a method to select a radio button in the group by given value/text,
# a method to return the values of all radio buttons in the group, a method
# to return if a radio button in the group is selected (will return
# the text of the selected radio button, if true), a method to return
# an array of PageObject::Elements::RadioButton objects representing
# the radio button group, and finally a method to check the existence
# of the radio button group.
#
# @example
# radio_button_group(:color, :name => "preferred_color")
# will generate 'select_color', 'color_values', 'color_selected?',
# 'color_elements', and 'color?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] shared identifier for the radio button group. Typically, a 'name' attribute.
# The valid keys are:
# * :name => Watir and Selenium
#
def radio_button_group(name, identifier)
define_method("select_#{name}") do |value|
platform.radio_buttons_for(identifier.clone).each do |radio_elem|
if radio_elem.value == value
return radio_elem.select
end
end
end
define_method("#{name}_values") do
result = []
platform.radio_buttons_for(identifier.clone).each do |radio_elem|
result << radio_elem.value
end
return result
end
define_method("#{name}_selected?") do
platform.radio_buttons_for(identifier.clone).each do |radio_elem|
return radio_elem.value if radio_elem.selected?
end
return false
end
define_method("#{name}_elements") do
return platform.radio_buttons_for(identifier.clone)
end
define_method("#{name}?") do
return platform.radio_buttons_for(identifier.clone).any?
end
end
alias_method :radio_group, :radio_button_group
#
# adds three methods - one to click a button, another to
# return the button element, and another to check the button's existence.
#
# @example
# button(:purchase, :id => 'purchase')
# # will generate 'purchase', 'purchase_element', and 'purchase?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a button. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :text => Watir only
# * :value => Watir and Selenium
# * :xpath => Watir and Selenium
# * :src => Watir and Selenium (input type=image only)
# * :alt => Watir and Selenium (input type=image only)
# @param optional block to be invoked when element method is called
#
def button(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'button_for', &block)
define_method(name) do
return platform.click_button_for identifier.clone unless block_given?
self.send("#{name}_element").click
end
end
#
# adds three methods - one to retrieve the text from a div,
# another to return the div element, and another to check the div's existence.
#
# @example
# div(:message, :id => 'message')
# # will generate 'message', 'message_element', and 'message?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a div. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :text => Watir and Selenium
# * :title => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def div(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'div_for', &block)
define_method(name) do
return platform.div_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
#
# adds three methods - one to retrieve the text from a span,
# another to return the span element, and another to check the span's existence.
#
# @example
# span(:alert, :id => 'alert')
# # will generate 'alert', 'alert_element', and 'alert?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a span. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :text => Watir and Selenium
# * :title => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def span(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'span_for', &block)
define_method(name) do
return platform.span_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
#
# adds three methods - one to return the text for the table, one
# to retrieve the table element, and another to
# check the table's existence. The existence method does not work
# on Selenium so it should not be called.
#
# @example
# table(:cart, :id => 'shopping_cart')
# # will generate a 'cart', 'cart_element' and 'cart?' method
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a table. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def table(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'table_for', &block)
define_method(name) do
return platform.table_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
#
# adds three methods - one to retrieve the text from a table cell,
# another to return the table cell element, and another to check the cell's
# existence.
#
# @example
# cell(:total, :id => 'total_cell')
# # will generate 'total', 'total_element', and 'total?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a cell. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :text => Watir and Selenium
# * :xpath => Watir and Selenium
# * :css => Selenium only
# @param optional block to be invoked when element method is called
#
def cell(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'cell_for', &block)
define_method("#{name}") do
return platform.cell_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
alias_method :td, :cell
#
# adds three methods - one to retrieve the text from a table row,
# another to return the table row element, and another to check the row's
# existence.
#
# @example
# row(:sums, :id => 'sum_row')
# # will generate 'sums', 'sums_element', and 'sums?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a cell. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :text => Watir only
# * :xpath => Watir and Selenium
# * :css => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def row(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'row_for', &block)
define_method("#{name}") do
return platform.row_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
#
# adds two methods - one to retrieve the image element, and another to
# check the image's existence.
#
# @example
# image(:logo, :id => 'logo')
# # will generate 'logo_element' and 'logo?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find an image. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :alt => Watir and Selenium
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :src => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def image(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'image_for', &block)
end
alias_method :img, :image
#
# adds two methods - one to retrieve the form element, and another to
# check the form's existence.
#
# @example
# form(:login, :id => 'login')
# # will generate 'login_element' and 'login?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a form. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :action => Watir and Selenium
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def form(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'form_for', &block)
end
#
# adds three methods - one to retrieve the text from a list item,
# another to return the list item element, and another to check the list item's
# existence.
#
# @example
# list_item(:item_one, :id => 'one')
# # will generate 'item_one', 'item_one_element', and 'item_one?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a list item. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :text => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def list_item(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'list_item_for', &block)
define_method(name) do
return platform.list_item_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
alias_method :li, :list_item
#
# adds three methods - one to return the text within the unordered
# list, one to retrieve the unordered list element, and another to
# check it's existence.
#
# @example
# unordered_list(:menu, :id => 'main_menu')
# # will generate 'menu', 'menu_element' and 'menu?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find an unordered list. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def unordered_list(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'unordered_list_for', &block)
define_method(name) do
return platform.unordered_list_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
alias_method :ul, :unordered_list
#
# adds three methods - one to return the text within the ordered
# list, one to retrieve the ordered list element, and another to
# test it's existence.
#
# @example
# ordered_list(:top_five, :id => 'top')
# # will generate 'top_five', 'top_five_element' and 'top_five?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find an ordered list. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def ordered_list(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'ordered_list_for', &block)
define_method(name) do
return platform.ordered_list_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
alias_method :ol, :ordered_list
#
# adds three methods - one to retrieve the text of a h1 element, another to
# retrieve a h1 element, and another to check for it's existence.
#
# @example
# h1(:title, :id => 'title')
# # will generate 'title', 'title_element', and 'title?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a H1. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def h1(name, identifier={:index => 0}, &block)
standard_methods(name, identifier,'h1_for', &block)
define_method(name) do
return platform.h1_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
#
# adds three methods - one to retrieve the text of a h2 element, another
# to retrieve a h2 element, and another to check for it's existence.
#
# @example
# h2(:title, :id => 'title')
# # will generate 'title', 'title_element', and 'title?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a H2. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def h2(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'h2_for', &block)
define_method(name) do
return platform.h2_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
#
# adds three methods - one to retrieve the text of a h3 element,
# another to return a h3 element, and another to check for it's existence.
#
# @example
# h3(:title, :id => 'title')
# # will generate 'title', 'title_element', and 'title?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a H3. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def h3(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'h3_for', &block)
define_method(name) do
return platform.h3_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
#
# adds three methods - one to retrieve the text of a h4 element,
# another to return a h4 element, and another to check for it's existence.
#
# @example
# h4(:title, :id => 'title')
# # will generate 'title', 'title_element', and 'title?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a H4. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def h4(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'h4_for', &block)
define_method(name) do
return platform.h4_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
#
# adds three methods - one to retrieve the text of a h5 element,
# another to return a h5 element, and another to check for it's existence.
#
# @example
# h5(:title, :id => 'title')
# # will generate 'title', 'title_element', and 'title?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a H5. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def h5(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'h5_for', &block)
define_method(name) do
return platform.h5_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
#
# adds three methods - one to retrieve the text of a h6 element,
# another to return a h6 element, and another to check for it's existence.
#
# @example
# h6(:title, :id => 'title')
# # will generate 'title', 'title_element', and 'title?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a H6. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def h6(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'h6_for', &block)
define_method(name) do
return platform.h6_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
#
# adds three methods - one to retrieve the text of a paragraph, another
# to retrieve a paragraph element, and another to check the paragraph's existence.
#
# @example
# paragraph(:title, :id => 'title')
# # will generate 'title', 'title_element', and 'title?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a paragraph. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def paragraph(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'paragraph_for', &block)
define_method(name) do
return platform.paragraph_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
alias_method :p, :paragraph
#
# adds three methods - one to set the file for a file field, another to retrieve
# the file field element, and another to check it's existence.
#
# @example
# file_field(:the_file, :id => 'file_to_upload')
# # will generate 'the_file=', 'the_file_element', and 'the_file?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a file_field. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :title => Watir and Selenium
# * :xpath => Watir and Selenium
# * :label => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def file_field(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'file_field_for', &block)
define_method("#{name}=") do |value|
return platform.file_field_value_set(identifier.clone, value) unless block_given?
self.send("#{name}_element").value = value
end
end
#
# adds three methods - one to retrieve the text from a label,
# another to return the label element, and another to check the label's existence.
#
# @example
# label(:message, :id => 'message')
# # will generate 'message', 'message_element', and 'message?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a label. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :text => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def label(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'label_for', &block)
define_method(name) do
return platform.label_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
#
# adds three methods - one to click the area,
# another to return the area element, and another to check the area's existence.
#
# @example
# area(:message, :id => 'message')
# # will generate 'message', 'message_element', and 'message?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find an area. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :text => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def area(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'area_for', &block)
define_method(name) do
return platform.click_area_for identifier.clone unless block_given?
self.send("#{name}_element").click
end
end
#
# adds two methods - one to return the canvas element and another to check
# the canvas's existence.
#
# @example
# canvas(:my_canvas, :id => 'canvas_id')
# # will generate 'my_canvas_element' and 'my_canvas?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a canvas. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def canvas(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'canvas_for', &block)
end
#
# adds two methods - one to return the audio element and another to check
# the audio's existence.
#
# @example
# audio(:acdc, :id => 'audio_id')
# # will generate 'acdc_element' and 'acdc?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find an audio element. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def audio(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'audio_for', &block)
end
#
# adds two methods - one to return the video element and another to check
# the video's existence.
#
# @example
# video(:movie, :id => 'video_id')
# # will generate 'movie_element' and 'movie?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a video element. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def video(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'video_for', &block)
end
#
# adds three methods - one to retrieve the text of a b element, another to
# retrieve a b element, and another to check for it's existence.
#
# @example
# b(:bold, :id => 'title')
# # will generate 'bold', 'bold_element', and 'bold?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a b. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def b(name, identifier={:index => 0}, &block)
standard_methods(name, identifier,'b_for', &block)
define_method(name) do
return platform.b_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
#
# adds three methods - one to retrieve the text of a i element, another to
# retrieve a i element, and another to check for it's existence.
#
# @example
# i(:italic, :id => 'title')
# # will generate 'italic', 'italic_element', and 'italic?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a i. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Watir and Selenium
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def i(name, identifier={:index => 0}, &block)
standard_methods(name, identifier,'i_for', &block)
define_method(name) do
return platform.i_text_for identifier.clone unless block_given?
self.send("#{name}_element").text
end
end
alias_method :icon, :i
#
# adds two methods - one to retrieve a svg, and another to check
# the svg's existence.
#
# @example
# svg(:circle, :id => 'circle')
# # will generate 'circle_element', and 'circle?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Hash] identifier how we find a svg. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def svg(name, identifier={:index => 0}, &block)
standard_methods(name, identifier, 'svg_for', &block)
end
#
# adds three methods - one to retrieve the text of an element, another
# to retrieve an element, and another to check the element's existence.
#
# @example
# element(:title, :header, :id => 'title')
# # will generate 'title', 'title_element', and 'title?' methods
#
# @param [Symbol] the name used for the generated methods
# @param [Symbol] the name of the tag for the element
# @param [Hash] identifier how we find an element. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def element(name, tag=:element, identifier={ :index => 0 }, &block)
# default tag to :element
#
# element 'button', css: 'some css'
#
# is the same as
#
# element 'button', :element, css: 'some css'
#
if tag.is_a?(Hash)
identifier = tag
tag = :element
end
define_method("#{name}") do
self.send("#{name}_element").text
end
define_method("#{name}_element") do
return call_block(&block) if block_given?
platform.element_for(tag, identifier.clone)
end
define_method("#{name}?") do
self.send("#{name}_element").exists?
end
end
#
# adds a method to return a collection of generic Element objects
# for a specific tag.
#
# @example
# elements(:title, :header, :id => 'title')
# # will generate ''title_elements'
#
# @param [Symbol] the name used for the generated methods
# @param [Symbol] the name of the tag for the element
# @param [Hash] identifier how we find an element. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
def elements(name, tag=:element, identifier={:index => 0}, &block)
# default tag to :element
#
# elements 'button', css: 'some css'
#
# is the same as
#
# elements 'button', :element, css: 'some css'
#
if tag.is_a?(Hash)
identifier = tag
tag = :element
end
define_method("#{name}_elements") do
return call_block(&block) if block_given?
platform.elements_for(tag, identifier.clone)
end
end
#
# adds a method to return a page object rooted at an element
#
# @example
# page_section(:navigation_bar, NavigationBar, :id => 'nav-bar')
# # will generate 'navigation_bar' and 'navigation_bar?'
#
# @param [Symbol] the name used for the generated methods
# @param [Class] the class to instantiate for the element
# @param [Hash] identifier how we find an element. You can use multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
#
def page_section(name, section_class, identifier)
define_method(name) do
platform.page_for(identifier, section_class)
end
end
#
# adds a method to return a collection of page objects rooted at elements
#
# @example
# page_sections(:articles, Article, :class => 'article')
# # will generate 'articles'
#
# @param [Symbol] the name used for the generated method
# @param [Class] the class to instantiate for each element
# @param [Hash] identifier how we find an element. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
#
def page_sections(name, section_class, identifier)
define_method(name) do
platform.pages_for(identifier, section_class)
end
end
#
# methods to generate accessors for types that follow the same
# pattern as element
#
# @example
# article(:my_article, :id => "article_id")
# will generate 'my_article', 'my_article_element' and 'my_article?'
# articles(:my_article, :id => 'article_id')
# will generate 'my_article_elements'
#
# @param [Symbol] the name used for the generated methods
# @param [Symbol] the name of the tag for the element
# @param [Hash] identifier how we find an element. You can use a multiple parameters
# by combining of any of the following except xpath. The valid keys are:
# * :class => Watir and Selenium
# * :css => Selenium only
# * :id => Watir and Selenium
# * :index => Watir and Selenium
# * :name => Watir and Selenium
# * :xpath => Watir and Selenium
# @param optional block to be invoked when element method is called
#
LocatorGenerator::BASIC_ELEMENTS.each do |tag|
define_method(tag) do |name, *identifier, &block|
identifier = identifier[0] ? identifier[0] : {:index => 0}
element(name, tag, identifier, &block)
end
define_method("#{tag}s") do |name, *identifier, &block|
identifier = identifier[0] ? identifier[0] : {:index => 0}
elements(name, tag, identifier, &block)
end unless tag == :param
end
def standard_methods(name, identifier, method, &block)
define_method("#{name}_element") do
return call_block(&block) if block_given?
platform.send(method, identifier.clone)
end
define_method("#{name}?") do
return call_block(&block).exists? if block_given?
platform.send(method, identifier.clone).exists?
end
end
#
# adds a method that will return an indexed property. The property will respond to
# the [] method with an object that has a set of normal page_object properties that
# correspond to the definitions included in the identifier_list parameter, with the
# "what" of the "how and what" substituted based on the index provided to the []
# method.
#
# @example
# indexed_property(:title, [
# [:text_field, :field_1, :id => 'table[%s].field_1'],
# [:button, :button_1, :id => 'table[%s].button_1'],
# [:text_field, :field_2, :name => 'table[%s].field_2']
# ])
# # will generate a title method that responds to []. title['foo'] will return an object
# # that responds to the normal methods expected for two text_fields and a button with the
# # given names, using the given how and what with 'foo' substituted for the %s. title[123]
# # will do the same, using the integer 123 instead.
#
# @param [Symbol] the name used for the generated method
# @param [Array] definitions an array of definitions to define on the indexed property. Each
# entry in the array should contain two symbols and a hash, corresponding to one of the standard
# page_object properties with a single substitution marker in each value in the hash,
# e.g. [:text_field, :field_1, :id => 'table[%s].field_1']
#
def indexed_property (name, identifier_list)
define_method("#{name}") do
IndexedProperties::TableOfElements.new(@browser, identifier_list)
end
end
#
# methods to fetch multiple elements of the same type
#
# adds a method to the page object to return all of the matching elements
#
# @example
# text_fields(:first_name, :id => "first_name")
# # will generate 'first_name_elements'
#
# @param [String] the name used for the generated methods
# @param [Hash] identifier how we find a text field. You can use a multiple parameters
# by combining of any of the following except xpath. The valid
# keys are the same ones supported by the standard methods.
# @param optional block to be invoked when element method is called
#
idx = LocatorGenerator::ADVANCED_ELEMENTS.find_index { |type| type == :checkbox }
elements = LocatorGenerator::ADVANCED_ELEMENTS.clone
elements[idx] = :checkboxe
elements.each do |method_name|
define_method("#{method_name}s") do |name, *identifier, &block|
define_method("#{name}_elements") do
return call_block(&block) unless block.nil?
platform_method = (method_name == :checkboxe) ? 'checkboxs_for' : "#{method_name.to_s}s_for"
platform.send platform_method, (identifier.first ? identifier.first.clone : {})
end
end
end
end
end