module PageObject::Accessors

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

Public Instance Methods

a(name, identifier={:index => 0}, &block)
Alias for: link
area(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 1050
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
audio(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 1100
def audio(name, identifier={:index => 0}, &block)
  standard_methods(name, identifier, 'audio_for', &block)
end
button(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 516
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
canvas(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 1077
def canvas(name, identifier={:index => 0}, &block)
  standard_methods(name, identifier, 'canvas_for', &block)
end
cell(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 633
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
Also aliased as: td
checkbox(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 390
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
direct_url(url)
Alias for: page_url
div(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 545
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
element(name, tag, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 1171
def element(name, tag, identifier={:index => 0}, &block)
  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
elements(name, tag, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 1204
def elements(name, tag, identifier={:index => 0}, &block)
  define_method("#{name}_elements") do
    return call_block(&block) if block_given?
    platform.elements_for(tag, identifier.clone)
  end
end
expected_element(element_name, timeout=::PageObject.default_element_wait) click to toggle source

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?
# File lib/page-object/accessors.rb, line 114
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
expected_element_visible(element_name, timeout=::PageObject.default_element_wait, check_visible=false) click to toggle source

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?
# File lib/page-object/accessors.rb, line 132
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
expected_title(expected_title) click to toggle source

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?
# File lib/page-object/accessors.rb, line 94
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
file_field(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 990
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
form(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 687
def form(name, identifier={:index => 0}, &block)
  standard_methods(name, identifier, 'form_for', &block)
end
h1(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 798
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
h2(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 825
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
h3(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 852
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
h4(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 879
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
h5(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 906
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
h6(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 933
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
hidden(name, identifier={:index => 0}, &block)
Alias for: hidden_field
hidden_field(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 246
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
Also aliased as: hidden
image(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 663
def image(name, identifier={:index => 0}, &block)
  standard_methods(name, identifier, 'image_for', &block)
end
Also aliased as: img
img(name, identifier={:index => 0}, &block)
Alias for: image
in_frame(identifier, frame=nil, &block) click to toggle source

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.

# File lib/page-object/accessors.rb, line 157
def in_frame(identifier, frame=nil, &block)
  frame = [] if frame.nil?
  frame << {frame: identifier}
  block.call(frame)
end
in_iframe(identifier, frame=nil, &block) click to toggle source

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.

# File lib/page-object/accessors.rb, line 181
def in_iframe(identifier, frame=nil, &block)
  frame = [] if frame.nil?
  frame << {iframe: identifier}
  block.call(frame)
end
indexed_property(name, identifier_list) click to toggle source

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']
# File lib/page-object/accessors.rb, line 1279
def indexed_property (name, identifier_list)
  define_method("#{name}") do
    IndexedProperties::TableOfElements.new(@browser, identifier_list)
  end
end
label(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 1018
def label(name, identifier={:index => 0}, &block)
  standard_methods(name, identifier, 'label_for', &block)
  define_method("choose_#{name}") do
    return platform.choose_label(identifier.clone) unless block_given?
    self.send("#{name}_element").click
  end
  define_method(name) do
    return platform.label_text_for identifier.clone unless block_given?
    self.send("#{name}_element").text
  end
end
li(name, identifier={:index => 0}, &block)
Alias for: list_item
list_item(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 712
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
Also aliased as: li
ol(name, identifier={:index => 0}, &block)
Alias for: ordered_list
ordered_list(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 770
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
Also aliased as: ol
p(name, identifier={:index => 0}, &block)
Alias for: paragraph
page_url(url) click to toggle source

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

# File lib/page-object/accessors.rb, line 40
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
Also aliased as: direct_url
paragraph(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 960
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
Also aliased as: p
params() click to toggle source

Return the params that exist on this page class

# File lib/page-object/accessors.rb, line 29
def params
  @params ||= {}
end
params=(the_params) click to toggle source

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

# File lib/page-object/accessors.rb, line 22
def params=(the_params)
  @params = the_params
end
radio(name, identifier={:index => 0}, &block)
Alias for: radio_button
radio_button(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 430
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
Also aliased as: radio
radio_button_group(name, identifier) click to toggle source

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

# File lib/page-object/accessors.rb, line 463
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
Also aliased as: radio_group
radio_group(name, identifier)
Alias for: radio_button_group
select(name, identifier={:index => 0}, &block)
Alias for: select_list
select_list(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 315
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
Also aliased as: select
span(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 574
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
standard_methods(name, identifier, method, &block) click to toggle source
# File lib/page-object/accessors.rb, line 1244
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
svg(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 1146
def svg(name, identifier={:index => 0}, &block)
  standard_methods(name, identifier, 'svg_for', &block)
end
table(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 603
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
td(name, identifier={:index => 0}, &block)
Alias for: cell
text_area(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 277
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
Also aliased as: textarea
text_field(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 212
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
textarea(name, identifier={:index => 0}, &block)
Alias for: text_area
ul(name, identifier={:index => 0}, &block)
Alias for: unordered_list
unordered_list(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 741
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
Also aliased as: ul
video(name, identifier={:index => 0}, &block) click to toggle source

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

# File lib/page-object/accessors.rb, line 1123
def video(name, identifier={:index => 0}, &block)
  standard_methods(name, identifier, 'video_for', &block)
end
wait_for_expected_title(expected_title, timeout=::PageObject.default_element_wait) click to toggle source

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?
# File lib/page-object/accessors.rb, line 67
def wait_for_expected_title(expected_title, timeout=::PageObject.default_element_wait)
  define_method("wait_for_expected_title?") do
    page_title = title
    has_expected_title = (expected_title === page_title)
    if not has_expected_title and not timeout.nil?
      wait_until(timeout, "Expected title '#{expected_title}' instead of '#{page_title}'") do 
        has_expected_title = (expected_title === page_title)
        has_expected_title
      end
    end
    raise "Expected title '#{expected_title}' instead of '#{page_title}'" unless has_expected_title
    has_expected_title
  end
end