page-object 1.0.2 → 1.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (88) hide show
  1. checksums.yaml +4 -4
  2. data/.ruby-version +1 -1
  3. data/.travis.yml +1 -0
  4. data/ChangeLog +10 -0
  5. data/README.md +1 -1
  6. data/features/bold.feature +21 -0
  7. data/features/html/indexed_property.html +14 -0
  8. data/features/html/multi_elements.html +1 -1
  9. data/features/html/static_elements.html +1 -2
  10. data/features/indexed_property.feature +15 -0
  11. data/features/multi_elements.feature +6 -0
  12. data/features/step_definitions/async_steps.rb +1 -1
  13. data/features/step_definitions/bold_steps.rb +12 -0
  14. data/features/step_definitions/check_box_steps.rb +2 -2
  15. data/features/step_definitions/indexed_property_steps.rb +47 -1
  16. data/features/step_definitions/label_steps.rb +1 -1
  17. data/features/step_definitions/multi_elements_steps.rb +13 -0
  18. data/features/step_definitions/select_list_steps.rb +1 -1
  19. data/features/step_definitions/table_steps.rb +4 -0
  20. data/features/support/page.rb +9 -0
  21. data/features/table.feature +12 -4
  22. data/lib/page-object.rb +6 -5
  23. data/lib/page-object/accessors.rb +78 -58
  24. data/lib/page-object/elements.rb +1 -0
  25. data/lib/page-object/elements/bold.rb +11 -0
  26. data/lib/page-object/elements/element.rb +12 -1
  27. data/lib/page-object/elements/table.rb +12 -1
  28. data/lib/page-object/indexed_properties.rb +20 -21
  29. data/lib/page-object/javascript/angularjs.rb +14 -0
  30. data/lib/page-object/javascript_framework_facade.rb +4 -2
  31. data/lib/page-object/locator_generator.rb +1 -0
  32. data/lib/page-object/page_populator.rb +0 -1
  33. data/lib/page-object/platforms/selenium_webdriver/button.rb +1 -1
  34. data/lib/page-object/platforms/selenium_webdriver/element.rb +1 -1
  35. data/lib/page-object/platforms/selenium_webdriver/page_object.rb +26 -10
  36. data/lib/page-object/platforms/selenium_webdriver/radio_button.rb +0 -7
  37. data/lib/page-object/platforms/watir_webdriver/element.rb +1 -1
  38. data/lib/page-object/platforms/watir_webdriver/page_object.rb +23 -8
  39. data/lib/page-object/platforms/watir_webdriver/radio_button.rb +0 -7
  40. data/lib/page-object/version.rb +1 -1
  41. data/lib/page-object/widgets.rb +7 -0
  42. data/page-object.gemspec +3 -3
  43. data/spec/page-object/accessors_spec.rb +40 -0
  44. data/spec/page-object/element_locators_spec.rb +340 -305
  45. data/spec/page-object/elements/area_spec.rb +8 -8
  46. data/spec/page-object/elements/bold_spec.rb +29 -0
  47. data/spec/page-object/elements/button_spec.rb +7 -7
  48. data/spec/page-object/elements/canvas_spec.rb +6 -6
  49. data/spec/page-object/elements/check_box_spec.rb +9 -9
  50. data/spec/page-object/elements/div_spec.rb +3 -3
  51. data/spec/page-object/elements/element_spec.rb +21 -21
  52. data/spec/page-object/elements/file_field_spec.rb +4 -4
  53. data/spec/page-object/elements/form_spec.rb +3 -3
  54. data/spec/page-object/elements/heading_spec.rb +8 -8
  55. data/spec/page-object/elements/hidden_field_spec.rb +3 -3
  56. data/spec/page-object/elements/image_spec.rb +14 -14
  57. data/spec/page-object/elements/label_spec.rb +3 -3
  58. data/spec/page-object/elements/link_spec.rb +6 -6
  59. data/spec/page-object/elements/list_item_spec.rb +4 -3
  60. data/spec/page-object/elements/nested_element_spec.rb +47 -47
  61. data/spec/page-object/elements/option_spec.rb +1 -1
  62. data/spec/page-object/elements/ordered_list_spec.rb +33 -33
  63. data/spec/page-object/elements/paragraph_spec.rb +3 -4
  64. data/spec/page-object/elements/select_list_spec.rb +52 -52
  65. data/spec/page-object/elements/selenium/radio_button_spec.rb +7 -13
  66. data/spec/page-object/elements/selenium/text_field_spec.rb +7 -7
  67. data/spec/page-object/elements/selenium_element_spec.rb +53 -53
  68. data/spec/page-object/elements/span_spec.rb +3 -3
  69. data/spec/page-object/elements/table_cell_spec.rb +3 -3
  70. data/spec/page-object/elements/table_row_spec.rb +22 -22
  71. data/spec/page-object/elements/table_spec.rb +28 -28
  72. data/spec/page-object/elements/text_area_spec.rb +5 -5
  73. data/spec/page-object/elements/unordered_list_spec.rb +33 -34
  74. data/spec/page-object/elements/watir_element_spec.rb +47 -48
  75. data/spec/page-object/javascript_framework_facade_spec.rb +6 -6
  76. data/spec/page-object/loads_platform_spec.rb +4 -4
  77. data/spec/page-object/page-object_spec.rb +103 -102
  78. data/spec/page-object/page_factory_spec.rb +43 -61
  79. data/spec/page-object/page_populator_spec.rb +44 -50
  80. data/spec/page-object/platforms/selenium_webdriver/selenium_page_object_spec.rb +15 -15
  81. data/spec/page-object/platforms/selenium_webdriver_spec.rb +6 -6
  82. data/spec/page-object/platforms/watir_webdriver/watir_page_object_spec.rb +4 -4
  83. data/spec/page-object/platforms/watir_webdriver_spec.rb +1 -1
  84. data/spec/page-object/selenium_accessors_spec.rb +166 -153
  85. data/spec/page-object/watir_accessors_spec.rb +265 -245
  86. data/spec/page-object/widget_spec.rb +62 -30
  87. data/spec/spec_helper.rb +8 -8
  88. metadata +20 -10
@@ -8,19 +8,19 @@ describe PageObject::Elements::Span do
8
8
  it "should map watir types to same" do
9
9
  [:class, :id, :index, :text, :title, :xpath].each do |t|
10
10
  identifier = span.watir_identifier_for t => 'value'
11
- identifier.keys.first.should == t
11
+ expect(identifier.keys.first).to eql t
12
12
  end
13
13
  end
14
14
 
15
15
  it "should map selenium types to same" do
16
16
  [:class, :id, :index, :name, :text, :title, :xpath].each do |t|
17
17
  key, value = span.selenium_identifier_for t => 'value'
18
- key.should == t
18
+ expect(key).to eql t
19
19
  end
20
20
  end
21
21
  end
22
22
 
23
23
  it "should register with tag_name :span" do
24
- ::PageObject::Elements.element_class_for(:span).should == ::PageObject::Elements::Span
24
+ expect(::PageObject::Elements.element_class_for(:span)).to eql ::PageObject::Elements::Span
25
25
  end
26
26
  end
@@ -5,17 +5,17 @@ describe PageObject::Elements::TableCell do
5
5
 
6
6
  context "interface" do
7
7
  it "should register with tag_name :td" do
8
- ::PageObject::Elements.element_class_for(:td).should == ::PageObject::Elements::TableCell
8
+ expect(::PageObject::Elements.element_class_for(:td)).to eql ::PageObject::Elements::TableCell
9
9
  end
10
10
 
11
11
  it "should register with tag_name :th" do
12
- ::PageObject::Elements.element_class_for(:th).should == ::PageObject::Elements::TableCell
12
+ expect(::PageObject::Elements.element_class_for(:th)).to eql ::PageObject::Elements::TableCell
13
13
  end
14
14
 
15
15
  it "should always be enabled" do
16
16
  table_cell_element = double('table_cell_element')
17
17
  table_cell = PageObject::Elements::TableCell.new(table_cell_element, :platform => :selenium_webdriver)
18
- table_cell.enabled?.should be true
18
+ expect(table_cell.enabled?).to be true
19
19
  end
20
20
  end
21
21
  end
@@ -8,62 +8,62 @@ describe PageObject::Elements::TableRow do
8
8
  describe "interface" do
9
9
 
10
10
  it "should register with tag_name :tr" do
11
- ::PageObject::Elements.element_class_for(:tr).should == ::PageObject::Elements::TableRow
11
+ expect(::PageObject::Elements.element_class_for(:tr)).to eql ::PageObject::Elements::TableRow
12
12
  end
13
13
 
14
14
  context "for selenium" do
15
15
  it "should return a table cell when indexed" do
16
16
  table_row = PageObject::Elements::TableRow.new(table_row_driver, :platform => :selenium_webdriver)
17
- table_row.stub(:columns).and_return(2)
18
- table_row_driver.should_receive(:find_elements).with(:xpath, ".//child::td|th").and_return(table_cell)
19
- table_cell.should_receive(:[]).and_return(table_cell)
20
- table_row[0].should be_instance_of PageObject::Elements::TableCell
17
+ allow(table_row).to receive(:columns).and_return(2)
18
+ expect(table_row_driver).to receive(:find_elements).with(:xpath, ".//child::td|th").and_return(table_cell)
19
+ expect(table_cell).to receive(:[]).and_return(table_cell)
20
+ expect(table_row[0]).to be_instance_of PageObject::Elements::TableCell
21
21
  end
22
22
 
23
23
  it "should retrun the number of columns" do
24
24
  table_row = PageObject::Elements::TableRow.new(table_row_driver, :platform => :selenium_webdriver)
25
- table_row_driver.should_receive(:find_elements).with(:xpath, ".//child::td|th").and_return(table_row_driver)
26
- table_row_driver.should_receive(:size).and_return(3)
27
- table_row.columns.should == 3
25
+ expect(table_row_driver).to receive(:find_elements).with(:xpath, ".//child::td|th").and_return(table_row_driver)
26
+ expect(table_row_driver).to receive(:size).and_return(3)
27
+ expect(table_row.columns).to eql 3
28
28
  end
29
29
 
30
30
  it "should iterate over the table columns" do
31
31
  table_row = PageObject::Elements::TableRow.new(table_row_driver, :platform => :selenium_webdriver)
32
- table_row.should_receive(:columns).and_return(2)
33
- table_row.stub(:[]).and_return(table_row_driver)
32
+ expect(table_row).to receive(:columns).and_return(2)
33
+ allow(table_row).to receive(:[]).and_return(table_row_driver)
34
34
  count = 0
35
35
  table_row.each { |e| count += 1 }
36
- count.should == 2
36
+ expect(count).to eql 2
37
37
  end
38
38
  end
39
39
 
40
40
  context "for watir" do
41
41
  before(:each) do
42
- table_row_driver.stub(:find_elements).and_return(table_row_driver)
42
+ allow(table_row_driver).to receive(:find_elements).and_return(table_row_driver)
43
43
  end
44
44
 
45
45
  it "should return a table cell when indexed" do
46
46
  table_row = PageObject::Elements::TableRow.new(table_row_driver, :platform => :watir_webdriver)
47
- table_row.stub(:columns).and_return(2)
48
- table_row_driver.should_receive(:[]).with(1).and_return(table_cell)
49
- table_row[1].should be_instance_of PageObject::Elements::TableCell
47
+ allow(table_row).to receive(:columns).and_return(2)
48
+ expect(table_row_driver).to receive(:[]).with(1).and_return(table_cell)
49
+ expect(table_row[1]).to be_instance_of PageObject::Elements::TableCell
50
50
  end
51
51
 
52
52
  it "should return the number of columns" do
53
53
  table_row = PageObject::Elements::TableRow.new(table_row_driver, :platform => :watir_webdriver)
54
- table_row_driver.stub(:wd).and_return(table_row_driver)
55
- table_row_driver.should_receive(:find_elements).with(:xpath, ".//child::td|th").and_return(table_row_driver)
56
- table_row_driver.should_receive(:size).and_return(3)
57
- table_row.columns.should == 3
54
+ allow(table_row_driver).to receive(:wd).and_return(table_row_driver)
55
+ expect(table_row_driver).to receive(:find_elements).with(:xpath, ".//child::td|th").and_return(table_row_driver)
56
+ expect(table_row_driver).to receive(:size).and_return(3)
57
+ expect(table_row.columns).to eql 3
58
58
  end
59
59
 
60
60
  it "should iterate over the table columns" do
61
61
  table_row = PageObject::Elements::TableRow.new(table_row_driver, :platform => :watir_webdriver)
62
- table_row.should_receive(:columns).and_return(2)
63
- table_row.stub(:[])
62
+ expect(table_row).to receive(:columns).and_return(2)
63
+ allow(table_row).to receive(:[])
64
64
  count = 0
65
65
  table_row.each { |e| count += 1 }
66
- count.should == 2
66
+ expect(count).to eql 2
67
67
  end
68
68
  end
69
69
  end
@@ -6,14 +6,14 @@ describe PageObject::Elements::Table do
6
6
  it "should map watir types to same" do
7
7
  [:class, :id, :index, :xpath].each do |t|
8
8
  identifier = PageObject::Elements::Table.watir_identifier_for t => 'value'
9
- identifier.keys.first.should == t
9
+ expect(identifier.keys.first).to eql t
10
10
  end
11
11
  end
12
12
 
13
13
  it "should map selenium types to same" do
14
14
  [:class, :id, :index, :name, :xpath].each do |t|
15
15
  key, value = PageObject::Elements::Table.selenium_identifier_for t => 'value'
16
- key.should == t
16
+ expect(key).to eql t
17
17
  end
18
18
  end
19
19
  end
@@ -22,44 +22,44 @@ describe PageObject::Elements::Table do
22
22
  let(:table_element) { double('table_element') }
23
23
 
24
24
  before(:each) do
25
- table_element.stub(:[]).and_return(table_element)
26
- table_element.stub(:find_elements).and_return(table_element)
25
+ allow(table_element).to receive(:[]).and_return(table_element)
26
+ allow(table_element).to receive(:find_elements).and_return(table_element)
27
27
  end
28
28
 
29
29
  it "should register with tag_name :table" do
30
- ::PageObject::Elements.element_class_for(:table).should == ::PageObject::Elements::Table
30
+ expect(::PageObject::Elements.element_class_for(:table)).to eql ::PageObject::Elements::Table
31
31
  end
32
32
 
33
33
  context "for watir" do
34
34
  let(:watir_table) { PageObject::Elements::Table.new(table_element, :platform => :watir_webdriver) }
35
35
 
36
36
  it "should return a table row when indexed" do
37
- table_element.stub(:[]).with(1).and_return(table_element)
38
- watir_table[1].should be_instance_of PageObject::Elements::TableRow
37
+ allow(table_element).to receive(:[]).with(1).and_return(table_element)
38
+ expect(watir_table[1]).to be_instance_of PageObject::Elements::TableRow
39
39
  end
40
40
 
41
41
  it "should return the first row" do
42
- table_element.stub(:[]).with(0).and_return(table_element)
43
- watir_table.first_row.should be_instance_of PageObject::Elements::TableRow
42
+ allow(table_element).to receive(:[]).with(0).and_return(table_element)
43
+ expect(watir_table.first_row).to be_instance_of PageObject::Elements::TableRow
44
44
  end
45
45
 
46
46
  it "shoudl return the last row" do
47
- table_element.stub(:[]).with(-1).and_return(table_element)
48
- watir_table.last_row.should be_instance_of PageObject::Elements::TableRow
47
+ allow(table_element).to receive(:[]).with(-1).and_return(table_element)
48
+ expect(watir_table.last_row).to be_instance_of PageObject::Elements::TableRow
49
49
  end
50
50
 
51
51
  it "should return the number of rows" do
52
- table_element.stub(:wd).and_return(table_element)
53
- table_element.should_receive(:find_elements).with(:xpath, ".//child::tr").and_return(table_element)
54
- table_element.should_receive(:size).and_return(2)
55
- watir_table.rows.should == 2
52
+ allow(table_element).to receive(:wd).and_return(table_element)
53
+ expect(table_element).to receive(:find_elements).with(:xpath, ".//child::tr").and_return(table_element)
54
+ expect(table_element).to receive(:size).and_return(2)
55
+ expect(watir_table.rows).to eql 2
56
56
  end
57
57
 
58
58
  it "should iterate over the table rows" do
59
- watir_table.should_receive(:rows).and_return(2)
59
+ expect(watir_table).to receive(:rows).and_return(2)
60
60
  count = 0
61
61
  watir_table.each { |e| count += 1 }
62
- count.should == 2
62
+ expect(count).to eql 2
63
63
  end
64
64
  end
65
65
 
@@ -67,31 +67,31 @@ describe PageObject::Elements::Table do
67
67
  let(:selenium_table) { PageObject::Elements::Table.new(table_element, :platform => :selenium_webdriver) }
68
68
 
69
69
  it "should return a table row when indexed" do
70
- table_element.should_receive(:find_elements).with(:xpath, ".//child::tr").and_return(table_element)
71
- selenium_table[1].should be_instance_of PageObject::Elements::TableRow
70
+ expect(table_element).to receive(:find_elements).with(:xpath, ".//child::tr").and_return(table_element)
71
+ expect(selenium_table[1]).to be_instance_of PageObject::Elements::TableRow
72
72
  end
73
73
 
74
74
  it "should return the first row" do
75
- table_element.stub(:[]).with(0).and_return(table_element)
76
- selenium_table.first_row.should be_instance_of PageObject::Elements::TableRow
75
+ allow(table_element).to receive(:[]).with(0).and_return(table_element)
76
+ expect(selenium_table.first_row).to be_instance_of PageObject::Elements::TableRow
77
77
  end
78
78
 
79
79
  it "shoudl return the last row" do
80
- table_element.stub(:[]).with(-1).and_return(table_element)
81
- selenium_table.last_row.should be_instance_of PageObject::Elements::TableRow
80
+ allow(table_element).to receive(:[]).with(-1).and_return(table_element)
81
+ expect(selenium_table.last_row).to be_instance_of PageObject::Elements::TableRow
82
82
  end
83
83
 
84
84
  it "should return the number of rows" do
85
- table_element.should_receive(:find_elements).with(:xpath, ".//child::tr").and_return(table_element)
86
- table_element.should_receive(:size).and_return(2)
87
- selenium_table.rows.should == 2
85
+ expect(table_element).to receive(:find_elements).with(:xpath, ".//child::tr").and_return(table_element)
86
+ expect(table_element).to receive(:size).and_return(2)
87
+ expect(selenium_table.rows).to eql 2
88
88
  end
89
89
 
90
90
  it "should iterate over the table rows" do
91
- selenium_table.should_receive(:rows).and_return(2)
91
+ allow(selenium_table).to receive(:rows).and_return(2)
92
92
  count = 0
93
93
  selenium_table.each { |e| count += 1 }
94
- count.should == 2
94
+ expect(count).to eql 2
95
95
  end
96
96
  end
97
97
  end
@@ -8,14 +8,14 @@ describe PageObject::Elements::TextArea do
8
8
  it "should map watir types to same" do
9
9
  [:class, :id, :index, :name, :xpath].each do |t|
10
10
  identifier = textarea.watir_identifier_for t => 'value'
11
- identifier.keys.first.should == t
11
+ expect(identifier.keys.first).to eql t
12
12
  end
13
13
  end
14
14
 
15
15
  it "should map selenium types to same" do
16
16
  [:class, :id, :name, :xpath, :index].each do |t|
17
17
  key, value = textarea.selenium_identifier_for t => 'value'
18
- key.should == t
18
+ expect(key).to eql t
19
19
  end
20
20
  end
21
21
  end
@@ -23,15 +23,15 @@ describe PageObject::Elements::TextArea do
23
23
  describe "interface" do
24
24
 
25
25
  it "should register with tag_name :textarea" do
26
- ::PageObject::Elements.element_class_for(:textarea).should == ::PageObject::Elements::TextArea
26
+ expect(::PageObject::Elements.element_class_for(:textarea)).to eql ::PageObject::Elements::TextArea
27
27
  end
28
28
 
29
29
  context "for Selenium" do
30
30
  it "should set its' value" do
31
31
  text_area_element = double('text_area')
32
32
  text_area = PageObject::Elements::TextArea.new(text_area_element, :platform => :selenium_webdriver)
33
- text_area_element.should_receive(:clear)
34
- text_area_element.should_receive(:send_keys).with('Joseph')
33
+ expect(text_area_element).to receive(:clear)
34
+ expect(text_area_element).to receive(:send_keys).with('Joseph')
35
35
  text_area.value = 'Joseph'
36
36
  end
37
37
  end
@@ -8,14 +8,14 @@ describe PageObject::Elements::UnorderedList do
8
8
  it "should map watir types to same" do
9
9
  [:class, :id, :index, :xpath].each do |t|
10
10
  identifier = ul.watir_identifier_for t => 'value'
11
- identifier.keys.first.should == t
11
+ expect(identifier.keys.first).to eql t
12
12
  end
13
13
  end
14
14
 
15
15
  it "should map selenium types to same" do
16
16
  [:class, :id, :index, :name, :xpath].each do |t|
17
17
  key, value = ul.selenium_identifier_for t => 'value'
18
- key.should == t
18
+ expect(key).to eql t
19
19
  end
20
20
  end
21
21
  end
@@ -24,71 +24,70 @@ describe PageObject::Elements::UnorderedList do
24
24
  let(:ul_element) { double('ul_element') }
25
25
 
26
26
  it "should register with tag_name :ul" do
27
- ::PageObject::Elements.element_class_for(:ul).should == ::PageObject::Elements::UnorderedList
27
+ expect(::PageObject::Elements.element_class_for(:ul)).to eql ::PageObject::Elements::UnorderedList
28
28
  end
29
29
 
30
30
  context "for watir" do
31
31
  it "should return a list item when indexed" do
32
32
  ul = PageObject::Elements::UnorderedList.new(ul_element, :platform => :watir_webdriver)
33
- ul_element.stub(:uls).and_return([ul_element])
34
- ul_element.stub(:find_elements).and_return(ul_element)
35
- ul_element.stub(:map).and_return([ul_element])
36
- ul_element.stub(:parent).and_return(ul_element)
37
- ul_element.stub(:element).and_return(ul_element)
38
- ul_element.stub(:==).and_return(true)
33
+ allow(ul_element).to receive(:uls).and_return([ul_element])
34
+ allow(ul_element).to receive(:find_elements).and_return(ul_element)
35
+ allow(ul_element).to receive(:map).and_return([ul_element])
36
+ allow(ul_element).to receive(:parent).and_return(ul_element)
37
+ allow(ul_element).to receive(:element).and_return(ul_element)
38
+ allow(ul_element).to receive(:==).and_return(true)
39
39
  ul[1]
40
40
  end
41
41
 
42
42
  it "should know how many items it contains" do
43
43
  ul = PageObject::Elements::UnorderedList.new(ul_element, :platform => :watir_webdriver)
44
- ul_element.stub(:uls).and_return([ul_element])
45
- ul_element.stub(:find_elements).and_return(ul_element)
46
- ul_element.stub(:map).and_return([ul_element])
47
- ul_element.stub(:parent).and_return(ul_element)
48
- ul_element.stub(:element).and_return(ul_element)
49
- ul_element.stub(:==).and_return(true)
50
- ul.items.should == 1
44
+ allow(ul_element).to receive(:uls).and_return([ul_element])
45
+ allow(ul_element).to receive(:find_elements).and_return(ul_element)
46
+ allow(ul_element).to receive(:map).and_return([ul_element])
47
+ allow(ul_element).to receive(:parent).and_return(ul_element)
48
+ allow(ul_element).to receive(:element).and_return(ul_element)
49
+ allow(ul_element).to receive(:==).and_return(true)
50
+ expect(ul.items).to eql 1
51
51
  end
52
52
 
53
53
  it "should know how to iterate over the items" do
54
54
  ul = PageObject::Elements::UnorderedList.new(ul_element, :platform => :watir_webdriver)
55
- ul.should_receive(:items).and_return(5)
56
- ul.stub(:[])
55
+ expect(ul).to receive(:items).and_return(5)
56
+ allow(ul).to receive(:[])
57
57
  count = 0
58
58
  ul.each { |item| count += 1 }
59
- count.should == 5
59
+ expect(count).to eql 5
60
60
  end
61
61
  end
62
62
 
63
63
  context "for selenium" do
64
64
  it "should return a list item when indexed" do
65
65
  ul = PageObject::Elements::UnorderedList.new(ul_element, :platform => :selenium_webdriver)
66
- ul_element.should_receive(:find_elements).and_return(ul_element)
67
- ul_element.should_receive(:map).and_return([ul_element])
68
- ul_element.should_receive(:parent).and_return(ul_element)
69
- ul_element.should_receive(:element).and_return(ul_element)
70
- ul_element.should_receive(:==).and_return(true)
66
+ expect(ul_element).to receive(:find_elements).and_return(ul_element)
67
+ expect(ul_element).to receive(:map).and_return([ul_element])
68
+ expect(ul_element).to receive(:parent).and_return(ul_element)
69
+ expect(ul_element).to receive(:element).and_return(ul_element)
70
+ expect(ul_element).to receive(:==).and_return(true)
71
71
  ul[1]
72
72
  end
73
73
 
74
74
  it "should know how many items it contains" do
75
75
  ul = PageObject::Elements::UnorderedList.new(ul_element, :platform => :selenium_webdriver)
76
- ul_element.should_receive(:find_elements).and_return(ul_element)
77
- ul_element.should_receive(:map).and_return([ul_element])
78
- ul_element.should_receive(:parent).and_return(ul_element)
79
- ul_element.should_receive(:element).and_return(ul_element)
80
- ul_element.should_receive(:==).and_return(true)
81
- ul.items.should == 1
76
+ expect(ul_element).to receive(:find_elements).and_return(ul_element)
77
+ expect(ul_element).to receive(:map).and_return([ul_element])
78
+ expect(ul_element).to receive(:parent).and_return(ul_element)
79
+ expect(ul_element).to receive(:element).and_return(ul_element)
80
+ expect(ul_element).to receive(:==).and_return(true)
81
+ expect(ul.items).to eql 1
82
82
  end
83
83
 
84
84
  it "should know how to iterate over the items" do
85
85
  ul = PageObject::Elements::UnorderedList.new(ul_element, :platform => :selenium_webdriver)
86
- ul.should_receive(:items).and_return(5)
87
- ul.stub(:[])
86
+ expect(ul).to receive(:items).and_return(5)
87
+ allow(ul).to receive(:[])
88
88
  count = 0
89
89
  ul.each { |item| count += 1 }
90
- count.should == 5
91
-
90
+ expect(count).to eql 5
92
91
  end
93
92
  end
94
93
  end
@@ -6,137 +6,136 @@ describe "Element for Watir" do
6
6
  let(:watir_element) { ::PageObject::Elements::Element.new(watir_driver, :platform => :watir_webdriver) }
7
7
 
8
8
  before(:each) do
9
- Selenium::WebDriver::Mouse.stub(:new).and_return(watir_driver)
9
+ allow(Selenium::WebDriver::Mouse).to receive(:new).and_return(watir_driver)
10
10
  end
11
11
 
12
12
  it "should know when it is visible" do
13
- watir_driver.stub(:present?).and_return(true)
14
- watir_driver.stub(:displayed?).and_return(true)
15
- watir_element.visible?.should == true
13
+ allow(watir_driver).to receive(:present?).and_return(true)
14
+ allow(watir_driver).to receive(:displayed?).and_return(true)
15
+ expect(watir_element.visible?).to eql true
16
16
  end
17
17
 
18
18
  it "should know when it is not visible" do
19
- watir_driver.stub(:present?).and_return(false)
20
- watir_driver.stub(:displayed?).and_return(false)
21
- watir_element.visible?.should == false
19
+ allow(watir_driver).to receive(:present?).and_return(false)
20
+ allow(watir_driver).to receive(:displayed?).and_return(false)
21
+ expect(watir_element.visible?).to eql false
22
22
  end
23
23
 
24
24
  it "should know when it exists" do
25
- watir_driver.stub(:exists?).and_return(true)
26
- watir_element.exists?.should == true
25
+ allow(watir_driver).to receive(:exists?).and_return(true)
26
+ expect(watir_element.exists?).to eql true
27
27
  end
28
28
 
29
29
  it "should know when it does not exist" do
30
- watir_driver.stub(:exists?).and_return(false)
31
- watir_driver.stub(:nil?).and_return(true)
32
- watir_element.exists?.should == false
30
+ allow(watir_driver).to receive(:exists?).and_return(false)
31
+ allow(watir_driver).to receive(:nil?).and_return(true)
32
+ expect(watir_element.exists?).to eql false
33
33
  end
34
34
 
35
35
  it "should be able to return the text contained in the element" do
36
- watir_driver.should_receive(:text).and_return("my text")
37
- watir_element.text.should == "my text"
36
+ expect(watir_driver).to receive(:text).and_return("my text")
37
+ expect(watir_element.text).to eql "my text"
38
38
  end
39
39
 
40
40
  it "should know when it is equal to another" do
41
- watir_driver.should_receive(:==).and_return(true)
42
- watir_element.should == watir_element
41
+ expect(watir_driver).to receive(:==).and_return(true)
42
+ expect(watir_element).to eq watir_element
43
43
  end
44
44
 
45
45
  it "should return its tag name" do
46
- watir_driver.should_receive(:tag_name).and_return("h1")
47
- watir_element.tag_name.should == "h1"
46
+ expect(watir_driver).to receive(:tag_name).and_return("h1")
47
+ expect(watir_element.tag_name).to eql "h1"
48
48
  end
49
49
 
50
50
  it "should know its value" do
51
- watir_driver.stub(:value).and_return("value")
52
- watir_driver.stub(:attribute).and_return("value")
53
- watir_element.value.should == "value"
51
+ allow(watir_driver).to receive(:value).and_return("value")
52
+ allow(watir_driver).to receive(:attribute).and_return("value")
53
+ expect(watir_element.value).to eql "value"
54
54
  end
55
55
 
56
56
  it "should know how to retrieve the value of an attribute" do
57
- watir_driver.stub(:attribute_value).and_return(true)
58
- watir_driver.stub(:attribute).and_return(true)
59
- watir_element.attribute("readonly").should be true
57
+ allow(watir_driver).to receive(:attribute_value).and_return(true)
58
+ allow(watir_driver).to receive(:attribute).and_return(true)
59
+ expect(watir_element.attribute("readonly")).to be true
60
60
  end
61
61
 
62
62
  it "should be clickable" do
63
- watir_driver.should_receive(:click)
63
+ expect(watir_driver).to receive(:click)
64
64
  watir_element.click
65
65
  end
66
66
 
67
67
  it "should be double clickable" do
68
-
69
- watir_driver.should_receive(:double_click)
68
+ expect(watir_driver).to receive(:double_click)
70
69
  watir_element.double_click
71
70
  end
72
71
 
73
72
  it "should be right clickable" do
74
- watir_driver.stub(:right_click)
75
- watir_driver.stub(:context_click)
73
+ allow(watir_driver).to receive(:right_click)
74
+ allow(watir_driver).to receive(:context_click)
76
75
  watir_element.right_click
77
76
  end
78
77
 
79
78
  it "should be able to block until it is present" do
80
- watir_driver.stub(:wait_until_present).with(10)
79
+ allow(watir_driver).to receive(:wait_until_present).with(10)
81
80
  watir_element.when_present(10)
82
81
  end
83
82
 
84
83
  it "should return the element when it is present" do
85
- watir_driver.stub(:wait_until_present).with(10)
84
+ allow(watir_driver).to receive(:wait_until_present).with(10)
86
85
  element = watir_element.when_present(10)
87
- element.should === watir_element
86
+ expect(element).to equal watir_element
88
87
  end
89
88
 
90
89
  it "should use the overriden wait when set" do
91
90
  PageObject.default_element_wait = 20
92
- watir_driver.stub(:wait_until_present).with(20)
91
+ allow(watir_driver).to receive(:wait_until_present).with(20)
93
92
  watir_element.when_present
94
93
  end
95
94
 
96
95
  it "should be able to block until it is visible" do
97
- ::Watir::Wait.stub(:until).with(10, "Element was not visible in 10 seconds")
98
- watir_driver.stub(:displayed?).and_return(true)
96
+ allow(::Watir::Wait).to receive(:until).with(10, "Element was not visible in 10 seconds")
97
+ allow(watir_driver).to receive(:displayed?).and_return(true)
99
98
  watir_element.when_visible(10)
100
99
  end
101
100
 
102
101
  it "should return the element when it is visible" do
103
- ::Watir::Wait.stub(:until).with(10, "Element was not visible in 10 seconds")
104
- watir_driver.stub(:displayed?).and_return(true)
102
+ allow(::Watir::Wait).to receive(:until).with(10, "Element was not visible in 10 seconds")
103
+ allow(watir_driver).to receive(:displayed?).and_return(true)
105
104
  element = watir_element.when_visible(10)
106
- element.should === watir_element
105
+ expect(element).to equal watir_element
107
106
  end
108
107
 
109
108
  it "should be able to block until it is not visible" do
110
- ::Watir::Wait.stub(:while).with(10, "Element still visible after 10 seconds")
111
- watir_driver.stub(:displayed?).and_return(false)
109
+ allow(::Watir::Wait).to receive(:while).with(10, "Element still visible after 10 seconds")
110
+ allow(watir_driver).to receive(:displayed?).and_return(false)
112
111
  watir_element.when_not_visible(10)
113
112
  end
114
113
 
115
114
  it "should return the element when it is not visible" do
116
- ::Watir::Wait.stub(:while).with(10, "Element still visible after 10 seconds")
117
- watir_driver.stub(:displayed?).and_return(false)
115
+ allow(::Watir::Wait).to receive(:while).with(10, "Element still visible after 10 seconds")
116
+ allow(watir_driver).to receive(:displayed?).and_return(false)
118
117
  element = watir_element.when_not_visible(10)
119
- element.should === watir_element
118
+ expect(element).to equal watir_element
120
119
  end
121
120
 
122
121
  it "should be able to block until a user define event fires true" do
123
- ::Watir::Wait.stub(:until).with(10, "Element blah")
122
+ allow(::Watir::Wait).to receive(:until).with(10, "Element blah")
124
123
  watir_element.wait_until(10, "Element blah") {true}
125
124
  end
126
125
 
127
126
  it "should send keys to the element" do
128
- watir_driver.should_receive(:send_keys).with([:control, 'a'])
127
+ expect(watir_driver).to receive(:send_keys).with([:control, 'a'])
129
128
  watir_element.send_keys([:control, 'a'])
130
129
  end
131
130
 
132
131
  it "should clear its' contents" do
133
- watir_driver.should_receive(:clear)
132
+ expect(watir_driver).to receive(:clear)
134
133
  watir_element.clear
135
134
  end
136
135
 
137
136
  it "should scroll into view" do
138
- watir_driver.stub(:wd).and_return(watir_driver)
139
- watir_driver.should_receive(:location_once_scrolled_into_view)
137
+ allow(watir_driver).to receive(:wd).and_return(watir_driver)
138
+ expect(watir_driver).to receive(:location_once_scrolled_into_view)
140
139
  watir_element.scroll_into_view
141
140
  end
142
141
  end