Module: PageObject::Accessors

Defined in:
lib/page-object/accessors.rb

Overview

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.

Instance Method Summary collapse

Instance Method Details

#area(name, identifier = {:index => 0}, &block) ⇒ Object

adds three methods - one to click the area, another to return the area element, and another to check the area's existence.

Examples:

area(:message, :id => 'message')
# will generate 'message', 'message_element', and 'message?' methods


843
844
845
846
847
848
849
# File 'lib/page-object/accessors.rb', line 843

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) ⇒ Object

adds two methods - one to return the audio element and another to check the audio's existence.

Examples:

audio(:acdc, :id => 'audio_id')
# will generate 'acdc_element' and 'acdc?' methods


879
880
881
# File 'lib/page-object/accessors.rb', line 879

def audio(name, identifier={:index => 0}, &block)
  standard_methods(name, identifier, 'audio_for', &block)
end

#b(name, identifier = {:index => 0}, &block) ⇒ Object

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.

Examples:

b(:bold, :id => 'title')
# will generate 'bold', 'bold_element', and 'bold?' methods


911
912
913
914
915
916
917
# File 'lib/page-object/accessors.rb', line 911

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

#button(name, identifier = {:index => 0}, &block) ⇒ Object

adds three methods - one to click a button, another to return the button element, and another to check the button's existence.

Examples:

button(:purchase, :id => 'purchase')
# will generate 'purchase', 'purchase_element', and 'purchase?' methods


432
433
434
435
436
437
438
# File 'lib/page-object/accessors.rb', line 432

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) ⇒ Object

adds two methods - one to return the canvas element and another to check the canvas's existence.

Examples:

canvas(:my_canvas, :id => 'canvas_id')
# will generate 'my_canvas_element' and 'my_canvas?' methods


863
864
865
# File 'lib/page-object/accessors.rb', line 863

def canvas(name, identifier={:index => 0}, &block)
  standard_methods(name, identifier, 'canvas_for', &block)
end

#cell(name, identifier = {:index => 0}, &block) ⇒ Object Also known as: td

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.

Examples:

cell(:total, :id => 'total_cell')
# will generate 'total', 'total_element', and 'total?' methods


514
515
516
517
518
519
520
# File 'lib/page-object/accessors.rb', line 514

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

#checkbox(name, identifier = {:index => 0}, &block) ⇒ Object

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.

Examples:

checkbox(:active, :name => "is_active")
# will generate 'check_active', 'uncheck_active', 'active_checked?',
# 'active_element', and 'active?' methods


326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
# File 'lib/page-object/accessors.rb', line 326

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

#div(name, identifier = {:index => 0}, &block) ⇒ Object

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.

Examples:

div(:message, :id => 'message')
# will generate 'message', 'message_element', and 'message?' methods


452
453
454
455
456
457
458
# File 'lib/page-object/accessors.rb', line 452

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 = :element, identifier = { :index => 0 }, &block) ⇒ Object

adds three methods - one to retrieve the text of an element, another to retrieve an element, and another to check the element's existence.

Examples:

element(:title, :header, :id => 'title')
# will generate 'title', 'title_element', and 'title?' methods


970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
# File 'lib/page-object/accessors.rb', line 970

def element(name, tag=:element, identifier={ :index => 0 }, &block)
  #
  # sets tag as element if not defined
  #
  if tag.is_a?(Hash)
    identifier = tag
    tag        = :element
  end

  standard_methods(name, identifier, 'element_for', &block)

  define_method("#{name}") do
    element = self.send("#{name}_element")

    %w(Button TextField Radio Hidden CheckBox FileField).each do |klass|
      next unless element.element.class.to_s  == "Watir::#{klass}"
      self.class.send(klass.gsub(/(.)([A-Z])/,'\1_\2').downcase, name, identifier, &block)
      return self.send name
    end
    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
  define_method("#{name}=") do |value|
    element = self.send("#{name}_element")

    klass = case element.element
            when Watir::TextField
              'text_field'
            when Watir::TextArea
              'text_area'
            when Watir::Select
              'select_list'
            when Watir::FileField
              'file_field'
            else
              raise "Can not set a #{element.element} element with #="
            end
    self.class.send(klass, name, identifier, &block)
    self.send("#{name}=", value)
  end
end

#elements(name, tag = :element, identifier = {:index => 0}, &block) ⇒ Object

adds a method to return a collection of generic Element objects for a specific tag.

Examples:

elements(:title, :header, :id => 'title')
# will generate ''title_elements'


1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
# File 'lib/page-object/accessors.rb', line 1031

def elements(name, tag=:element, identifier={:index => 0}, &block)
  #
  # sets tag as element if not defined
  #
  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

#expected_element(element_name, timeout = ::PageObject.default_element_wait) ⇒ boolean

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.

Examples:

Specify a text box named :address expected on the page within 10 seconds

expected_element(:address, 10)
page.has_expected_element?


109
110
111
112
113
# File 'lib/page-object/accessors.rb', line 109

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) ⇒ boolean

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.

Examples:

Specify a text box named :address expected on the page within 10 seconds

expected_element_visible(:address, 10)
page.has_expected_element_visible?


127
128
129
130
131
132
# File 'lib/page-object/accessors.rb', line 127

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) ⇒ boolean

Creates a method that compares the expected_title of a page against the actual.

Examples:

Specify 'Google' as the expected title of a page

expected_title "Google"
page.has_expected_title?

Raises:

  • An exception if expected_title does not match actual title



89
90
91
92
93
94
95
96
# File 'lib/page-object/accessors.rb', line 89

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) ⇒ Object

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.

Examples:

file_field(:the_file, :id => 'file_to_upload')
# will generate 'the_file=', 'the_file_element', and 'the_file?' methods


803
804
805
806
807
808
809
# File 'lib/page-object/accessors.rb', line 803

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) ⇒ Object

adds two methods - one to retrieve the form element, and another to check the form's existence.

Examples:

form(:login, :id => 'login')
# will generate 'login_element' and 'login?' methods


579
580
581
# File 'lib/page-object/accessors.rb', line 579

def form(name, identifier={:index => 0}, &block)
  standard_methods(name, identifier, 'form_for', &block)
end

#h1(name, identifier = {:index => 0}, &block) ⇒ Object

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.

Examples:

h1(:title, :id => 'title')
# will generate 'title', 'title_element', and 'title?' methods


662
663
664
665
666
667
668
# File 'lib/page-object/accessors.rb', line 662

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) ⇒ Object

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.

Examples:

h2(:title, :id => 'title')
# will generate 'title', 'title_element', and 'title?' methods


682
683
684
685
686
687
688
# File 'lib/page-object/accessors.rb', line 682

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) ⇒ Object

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.

Examples:

h3(:title, :id => 'title')
# will generate 'title', 'title_element', and 'title?' methods


702
703
704
705
706
707
708
# File 'lib/page-object/accessors.rb', line 702

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) ⇒ Object

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.

Examples:

h4(:title, :id => 'title')
# will generate 'title', 'title_element', and 'title?' methods


722
723
724
725
726
727
728
# File 'lib/page-object/accessors.rb', line 722

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) ⇒ Object

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.

Examples:

h5(:title, :id => 'title')
# will generate 'title', 'title_element', and 'title?' methods


742
743
744
745
746
747
748
# File 'lib/page-object/accessors.rb', line 742

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) ⇒ Object

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.

Examples:

h6(:title, :id => 'title')
# will generate 'title', 'title_element', and 'title?' methods


762
763
764
765
766
767
768
# File 'lib/page-object/accessors.rb', line 762

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_field(name, identifier = {:index => 0}, &block) ⇒ Object Also known as: hidden

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.

Examples:

hidden_field(:user_id, :id => "user_identity")
# will generate 'user_id', 'user_id_element' and 'user_id?' methods


221
222
223
224
225
226
227
# File 'lib/page-object/accessors.rb', line 221

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

#i(name, identifier = {:index => 0}, &block) ⇒ Object Also known as: icon

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.

Examples:

i(:italic, :id => 'title')
# will generate 'italic', 'italic_element', and 'italic?' methods


931
932
933
934
935
936
937
# File 'lib/page-object/accessors.rb', line 931

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

#image(name, identifier = {:index => 0}, &block) ⇒ Object Also known as: img

adds three methods - one to retrieve the image element, another to check the load status of the image, and another to check the image's existence.

Examples:

image(:logo, :id => 'logo')
# will generate 'logo_element', 'logo_loaded?', and 'logo?' methods


558
559
560
561
562
563
564
# File 'lib/page-object/accessors.rb', line 558

def image(name, identifier={:index => 0}, &block)
  standard_methods(name, identifier, 'image_for', &block)
  define_method("#{name}_loaded?") do
    return platform.image_loaded_for identifier.clone unless block_given?
    self.send("#{name}_element").loaded?
  end
end

#in_frame(identifier, frame = nil, &block) ⇒ Object

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.

Examples:

in_frame(:id => 'frame_id') do |frame|
  text_field(:first_name, :id => 'fname', :frame => frame)
end


152
153
154
155
156
# File 'lib/page-object/accessors.rb', line 152

def in_frame(identifier, frame=nil, &block)
  frame = frame.nil? ? [] : frame.dup
  frame << {frame: identifier}
  block.call(frame)
end

#in_iframe(identifier, frame = nil, &block) ⇒ Object

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.

Examples:

in_iframe(:id => 'frame_id') do |frame|
  text_field(:first_name, :id => 'fname', :frame => frame)
end


176
177
178
179
180
# File 'lib/page-object/accessors.rb', line 176

def in_iframe(identifier, frame=nil, &block)
  frame = frame.nil? ? [] : frame.dup
  frame << {iframe: identifier}
  block.call(frame)
end

#indexed_property(name, identifier_list) ⇒ Object

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.

Examples:

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.


1141
1142
1143
1144
1145
# File 'lib/page-object/accessors.rb', line 1141

def indexed_property (name, identifier_list)
  define_method("#{name}") do
    IndexedProperties::TableOfElements.new(@browser, identifier_list)
  end
end

#label(name, identifier = {:index => 0}, &block) ⇒ Object

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.

Examples:

label(:message, :id => 'message')
# will generate 'message', 'message_element', and 'message?' methods


823
824
825
826
827
828
829
# File 'lib/page-object/accessors.rb', line 823

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 select a link, another to return a PageObject::Elements::Link object representing the link, and another that checks the link's existence.

Examples:

link(:add_to_cart, :text => "Add to Cart")
# will generate 'add_to_cart', 'add_to_cart_element', and 'add_to_cart?' methods


302
303
304
305
306
307
308
# File 'lib/page-object/accessors.rb', line 302

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

#list_item(name, identifier = {:index => 0}, &block) ⇒ Object Also known as: li

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.

Examples:

list_item(:item_one, :id => 'one')
# will generate 'item_one', 'item_one_element', and 'item_one?' methods


596
597
598
599
600
601
602
# File 'lib/page-object/accessors.rb', line 596

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

#ordered_list(name, identifier = {:index => 0}, &block) ⇒ Object Also known as: ol

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.

Examples:

ordered_list(:top_five, :id => 'top')
# will generate 'top_five', 'top_five_element' and 'top_five?' methods


640
641
642
643
644
645
646
# File 'lib/page-object/accessors.rb', line 640

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

#page_section(name, section_class, identifier) ⇒ Object

adds a method to return a page object rooted at an element

Examples:

page_section(:navigation_bar, NavigationBar, :id => 'nav-bar')
# will generate 'navigation_bar'


1057
1058
1059
1060
1061
# File 'lib/page-object/accessors.rb', line 1057

def page_section(name, section_class, identifier)
  define_method(name) do
    platform.page_for(identifier, section_class)
  end
end

#page_sections(name, section_class, identifier) ⇒ Object

adds a method to return a collection of page objects rooted at elements

Examples:

page_sections(:articles, Article, :class => 'article')
# will generate 'articles'


1074
1075
1076
1077
1078
# File 'lib/page-object/accessors.rb', line 1074

def page_sections(name, section_class, identifier)
  define_method(name) do
    platform.pages_for(identifier, section_class)
  end
end

#page_url(url) ⇒ Object Also known as: direct_url

Specify the url for the page. A call to this method will generate a 'goto' method to take you to the page.



37
38
39
40
41
42
43
44
45
46
47
48
49
# File 'lib/page-object/accessors.rb', line 37

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

#paragraph(name, identifier = {:index => 0}, &block) ⇒ Object Also known as: p

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.

Examples:

paragraph(:title, :id => 'title')
# will generate 'title', 'title_element', and 'title?' methods


782
783
784
785
786
787
788
# File 'lib/page-object/accessors.rb', line 782

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

#paramsObject

Return the params that exist on this page class



26
27
28
# File 'lib/page-object/accessors.rb', line 26

def params
  @params ||= {}
end

#params=(the_params) ⇒ Object

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



19
20
21
# File 'lib/page-object/accessors.rb', line 19

def params=(the_params)
  @params = the_params
end

#radio_button(name, identifier = {:index => 0}, &block) ⇒ Object Also known as: radio

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.

Examples:

radio_button(:north, :id => "north")
# will generate 'select_north', 'north_selected?',
# 'north_element', and 'north?' methods


357
358
359
360
361
362
363
364
365
366
367
# File 'lib/page-object/accessors.rb', line 357

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

#radio_button_group(name, identifier) ⇒ Object Also known as: radio_group

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.

radio_button_group(:color, :name => “preferred_color”) will generate 'select_color', 'color_values', 'color_selected?', 'color_elements', and 'color?' methods

The valid keys are:

  • :name



390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
# File 'lib/page-object/accessors.rb', line 390

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

#row(name, identifier = {:index => 0}, &block) ⇒ Object

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.

Examples:

row(:sums, :id => 'sum_row')
# will generate 'sums', 'sums_element', and 'sums?' methods


537
538
539
540
541
542
543
# File 'lib/page-object/accessors.rb', line 537

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

#select_list(name, identifier = {:index => 0}, &block) ⇒ Object Also known as: select

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.

Examples:

select_list(:state, :id => "state")
# will generate 'state', 'state=', 'state_element', 'state?', "state_options" methods


272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
# File 'lib/page-object/accessors.rb', line 272

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

#span(name, identifier = {:index => 0}, &block) ⇒ Object

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.

Examples:

span(:alert, :id => 'alert')
# will generate 'alert', 'alert_element', and 'alert?' methods


472
473
474
475
476
477
478
# File 'lib/page-object/accessors.rb', line 472

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) ⇒ Object



1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
# File 'lib/page-object/accessors.rb', line 1106

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) ⇒ Object

adds two methods - one to retrieve a svg, and another to check the svg's existence.

Examples:

svg(:circle, :id => 'circle')
# will generate 'circle_element', and 'circle?' methods


952
953
954
# File 'lib/page-object/accessors.rb', line 952

def svg(name, identifier={:index => 0}, &block)
  standard_methods(name, identifier, 'svg_for', &block)
end

#table(name, identifier = {:index => 0}, &block) ⇒ Object

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.

Examples:

table(:cart, :id => 'shopping_cart')
# will generate a 'cart', 'cart_element' and 'cart?' method


493
494
495
496
497
498
499
# File 'lib/page-object/accessors.rb', line 493

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

#text_area(name, identifier = {:index => 0}, &block) ⇒ Object Also known as: textarea

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.

Examples:

text_area(:address, :id => "address")
# will generate 'address', 'address=', 'address_element',
# 'address?' methods


244
245
246
247
248
249
250
251
252
253
254
# File 'lib/page-object/accessors.rb', line 244

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

#text_field(name, identifier = {:index => 0}, &block) ⇒ Object

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.

Examples:

text_field(:first_name, :id => "first_name")
# will generate 'first_name', 'first_name=', 'first_name_element',
# 'first_name?' methods


196
197
198
199
200
201
202
203
204
205
206
# File 'lib/page-object/accessors.rb', line 196

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

#unordered_list(name, identifier = {:index => 0}, &block) ⇒ Object Also known as: ul

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.

Examples:

unordered_list(:menu, :id => 'main_menu')
# will generate 'menu', 'menu_element' and 'menu?' methods


618
619
620
621
622
623
624
# File 'lib/page-object/accessors.rb', line 618

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

#video(name, identifier = {:index => 0}, &block) ⇒ Object

adds two methods - one to return the video element and another to check the video's existence.

Examples:

video(:movie, :id => 'video_id')
# will generate 'movie_element' and 'movie?' methods


895
896
897
# File 'lib/page-object/accessors.rb', line 895

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) ⇒ boolean

Creates a method that waits the expected_title of a page to match the actual.

Examples:

Specify 'Google' as the expected title of a page

expected_title "Google"
page.has_expected_title?

Raises:

  • An exception if expected_title does not match actual title



64
65
66
67
68
69
70
71
72
73
74
75
76
# File 'lib/page-object/accessors.rb', line 64

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