watir 1.4.1 → 7.3.0

data/spec/watirspec/elements/select_lists_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'watirspec_helper'
+
+module Watir
+  describe SelectCollection do
+    before do
+      browser.goto(WatirSpec.url_for('forms_with_input_elements.html'))
+    end
+
+    describe 'with selectors' do
+      it 'returns the matching elements' do
+        list = [browser.select_list(name: 'delete_user_username')]
+        expect(browser.select_lists(name: 'delete_user_username').to_a).to eq list
+      end
+    end
+
+    describe '#length' do
+      it 'returns the correct number of select lists on the page' do
+        expect(browser.select_lists.length).to eq 6
+      end
+    end
+
+    describe '#[]' do
+      it 'returns the correct item' do
+        expect(browser.select_lists[0].value).to eq '2'
+        expect(browser.select_lists[0].name).to eq 'new_user_country'
+        expect(browser.select_lists[0]).not_to be_multiple
+        expect(browser.select_lists[1]).to be_multiple
+      end
+    end
+
+    describe '#each' do
+      it 'iterates through the select lists correctly' do
+        count = 0
+
+        browser.select_lists.each_with_index do |l, index|
+          expect(browser.select_list(index: index).name).to eq l.name
+          expect(browser.select_list(index: index).id).to eq l.id
+          expect(browser.select_list(index: index).value).to eq l.value
+
+          count += 1
+        end
+
+        expect(count).to be > 0
+      end
+    end
+  end
+end

data/spec/watirspec/elements/span_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'watirspec_helper'
+
+module Watir
+  describe Span do
+    before do
+      browser.goto(WatirSpec.url_for('non_control_elements.html'))
+    end
+
+    # Exists method
+    describe '#exist?' do
+      it "returns true if the 'span' exists" do
+        expect(browser.span(id: 'lead')).to exist
+        expect(browser.span(id: /lead/)).to exist
+        expect(browser.span(text: 'Dubito, ergo cogito, ergo sum.')).to exist
+        expect(browser.span(class: 'lead')).to exist
+        expect(browser.span(class: /lead/)).to exist
+        expect(browser.span(index: 0)).to exist
+        expect(browser.span(xpath: "//span[@id='lead']")).to exist
+      end
+
+      it 'visible text is found by regular expression with visible text locator' do
+        expect(browser.span(visible_text: /Dubito, ergo cogito, ergo sum/)).to exist
+      end
+
+      it 'returns the first span if given no args' do
+        expect(browser.span).to exist
+      end
+
+      it "returns false if the element doesn't exist" do
+        expect(browser.span(id: 'no_such_id')).not_to exist
+        expect(browser.span(id: /no_such_id/)).not_to exist
+        expect(browser.span(text: 'no_such_text')).not_to exist
+        expect(browser.span(text: /no_such_text/)).not_to exist
+        expect(browser.span(class: 'no_such_class')).not_to exist
+        expect(browser.span(class: /no_such_class/)).not_to exist
+        expect(browser.span(index: 1337)).not_to exist
+        expect(browser.span(xpath: "//span[@id='no_such_id']")).not_to exist
+      end
+
+      it "raises TypeError when 'what' argument is invalid" do
+        expect { browser.span(id: 3.14).exists? }.to raise_error(TypeError)
+      end
+    end
+
+    # Attribute methods
+    describe '#id' do
+      it 'returns the id attribute' do
+        expect(browser.span(index: 0).id).to eq 'lead'
+      end
+
+      it "returns an empty string if the element exists and the attribute doesn't" do
+        expect(browser.span(index: 2).id).to eq ''
+      end
+
+      it "raises UnknownObjectException if the span doesn't exist" do
+        expect { browser.span(id: 'no_such_id').id }.to raise_unknown_object_exception
+        expect { browser.span(index: 1337).id }.to raise_unknown_object_exception
+      end
+    end
+
+    describe '#title' do
+      it 'returns the title attribute' do
+        expect(browser.span(index: 0).title).to eq 'Lorem ipsum'
+      end
+
+      it "returns an empty string if the element exists and the attribute doesn't" do
+        expect(browser.span(index: 2).title).to eq ''
+      end
+
+      it "raises UnknownObjectException if the span doesn't exist" do
+        expect { browser.span(id: 'no_such_id').title }.to raise_unknown_object_exception
+        expect { browser.span(xpath: "//span[@id='no_such_id']").title }.to raise_unknown_object_exception
+      end
+    end
+
+    describe '#text' do
+      it 'returns the text of the span' do
+        msg = 'Sed pretium metus et quam. Nullam odio dolor, vestibulum non, tempor ut, vehicula sed, sapien. ' \
+              'Vestibulum placerat ligula at quam. Pellentesque habitant morbi tristique senectus et netus et ' \
+              'malesuada fames ac turpis egestas.'
+        expect(browser.span(index: 1).text).to eq msg
+      end
+
+      it "returns an empty string if the element doesn't contain any text" do
+        expect(browser.span(index: 4).text).to eq ''
+      end
+
+      it "raises UnknownObjectException if the span doesn't exist" do
+        expect { browser.span(id: 'no_such_id').text }.to raise_unknown_object_exception
+        expect { browser.span(xpath: "//span[@id='no_such_id']").text }.to raise_unknown_object_exception
+      end
+    end
+
+    describe '#respond_to?' do
+      it 'returns true for all attribute methods' do
+        expect(browser.span(index: 0)).to respond_to(:class_name)
+        expect(browser.span(index: 0)).to respond_to(:id)
+        expect(browser.span(index: 0)).to respond_to(:title)
+        expect(browser.span(index: 0)).to respond_to(:text)
+      end
+    end
+
+    # Other
+    describe '#click', except: {headless: true} do
+      it 'fires events' do
+        expect(browser.span(class: 'footer').text).not_to include('Javascript')
+        browser.span(class: 'footer').click
+        expect(browser.span(class: 'footer').text).to include('Javascript')
+      end
+
+      it "raises UnknownObjectException if the span doesn't exist" do
+        expect { browser.span(id: 'no_such_id').click }.to raise_unknown_object_exception
+        expect { browser.span(title: 'no_such_title').click }.to raise_unknown_object_exception
+      end
+    end
+  end
+end

data/spec/watirspec/elements/spans_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'watirspec_helper'
+
+module Watir
+  describe SpanCollection do
+    before do
+      browser.goto(WatirSpec.url_for('non_control_elements.html'))
+    end
+
+    describe 'with selectors' do
+      it 'returns the matching elements' do
+        expect(browser.spans(class: 'footer').to_a).to eq [browser.span(class: 'footer')]
+      end
+    end
+
+    describe '#length' do
+      it 'returns the number of spans' do
+        expect(browser.spans.length).to eq 8
+      end
+    end
+
+    describe '#[]' do
+      it 'returns the p at the given index' do
+        expect(browser.spans[0].id).to eq 'lead'
+      end
+    end
+
+    describe '#each' do
+      it 'iterates through spans correctly' do
+        count = 0
+
+        browser.spans.each_with_index do |s, index|
+          expect(s.id).to eq browser.span(index: index).id
+          count += 1
+        end
+
+        expect(count).to be > 0
+      end
+    end
+  end
+end

data/spec/watirspec/elements/strong_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'watirspec_helper'
+
+module Watir
+  describe 'Strong' do
+    before do
+      browser.goto(WatirSpec.url_for('non_control_elements.html'))
+    end
+
+    # Exists method
+    describe '#exist?' do
+      it 'returns true if the element exists' do
+        expect(browser.strong(id: 'descartes')).to exist
+        expect(browser.strong(id: /descartes/)).to exist
+        expect(browser.strong(text: 'Dubito, ergo cogito, ergo sum.')).to exist
+        expect(browser.strong(class: 'descartes')).to exist
+        expect(browser.strong(class: /descartes/)).to exist
+        expect(browser.strong(index: 0)).to exist
+        expect(browser.strong(xpath: "//strong[@id='descartes']")).to exist
+      end
+
+      it 'visible text is found by regular expression with text locator' do
+        expect(browser.strong(visible_text: /Dubito, ergo cogito, ergo sum/)).to exist
+      end
+
+      it 'returns the first strong if given no args' do
+        expect(browser.strong).to exist
+      end
+
+      it "returns false if the element doesn't exist" do
+        expect(browser.strong(id: 'no_such_id')).not_to exist
+        expect(browser.strong(id: /no_such_id/)).not_to exist
+        expect(browser.strong(text: 'no_such_text')).not_to exist
+        expect(browser.strong(text: /no_such_text/)).not_to exist
+        expect(browser.strong(class: 'no_such_class')).not_to exist
+        expect(browser.strong(class: /no_such_class/)).not_to exist
+        expect(browser.strong(index: 1337)).not_to exist
+        expect(browser.strong(xpath: "//strong[@id='no_such_id']")).not_to exist
+      end
+
+      it "raises TypeError when 'what' argument is invalid" do
+        expect { browser.strong(id: 3.14).exists? }.to raise_error(TypeError)
+      end
+    end
+
+    # Attribute methods
+    describe '#id' do
+      it 'returns the id attribute' do
+        expect(browser.strong(index: 0).id).to eq 'descartes'
+      end
+
+      it "raises UnknownObjectException if the element doesn't exist" do
+        expect { browser.strong(id: 'no_such_id').id }.to raise_unknown_object_exception
+        expect { browser.strong(index: 1337).id }.to raise_unknown_object_exception
+      end
+    end
+
+    describe '#text' do
+      it 'returns the text of the element' do
+        expect(browser.strong(index: 0).text).to eq 'Dubito, ergo cogito, ergo sum.'
+      end
+
+      it "raises UnknownObjectException if the element doesn't exist" do
+        expect { browser.strong(id: 'no_such_id').text }.to raise_unknown_object_exception
+        expect { browser.strong(xpath: "//strong[@id='no_such_id']").text }.to raise_unknown_object_exception
+      end
+    end
+
+    describe '#respond_to?' do
+      it 'returns true for all attribute methods' do
+        expect(browser.strong(index: 0)).to respond_to(:class_name)
+        expect(browser.strong(index: 0)).to respond_to(:id)
+        expect(browser.strong(index: 0)).to respond_to(:text)
+      end
+    end
+  end
+end

data/spec/watirspec/elements/strongs_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'watirspec_helper'
+
+module Watir
+  describe 'Strongs' do
+    before do
+      browser.goto(WatirSpec.url_for('non_control_elements.html'))
+    end
+
+    describe 'with selectors' do
+      it 'returns the matching elements' do
+        expect(browser.strongs(class: 'descartes').to_a).to eq [browser.strong(class: 'descartes')]
+      end
+    end
+
+    describe '#length' do
+      it 'returns the number of divs' do
+        expect(browser.strongs.length).to eq 2
+      end
+    end
+
+    describe '#[]' do
+      it 'returns the div at the given index' do
+        expect(browser.strongs[0].id).to eq 'descartes'
+      end
+    end
+
+    describe '#each' do
+      it 'iterates through divs correctly' do
+        count = 0
+
+        browser.strongs.each_with_index do |s, index|
+          strong = browser.strong(index: index)
+          expect(s.id).to eq strong.id
+          expect(s.class_name).to eq strong.class_name
+
+          count += 1
+        end
+
+        expect(count).to be > 0
+      end
+    end
+  end
+end

data/spec/watirspec/elements/table_spec.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require 'watirspec_helper'
+
+module Watir
+  describe Table do
+    before do
+      browser.goto(WatirSpec.url_for('tables.html'))
+    end
+
+    # Exists
+    describe '#exists?' do
+      it 'returns true if the table exists' do
+        expect(browser.table(id: 'axis_example')).to exist
+        expect(browser.table(id: /axis_example/)).to exist
+        expect(browser.table(index: 0)).to exist
+        expect(browser.table(xpath: "//table[@id='axis_example']")).to exist
+      end
+
+      it 'returns the first table if given no args' do
+        expect(browser.table).to exist
+      end
+
+      it 'returns false if the table does not exist' do
+        expect(browser.table(id: 'no_such_id')).not_to exist
+        expect(browser.table(id: /no_such_id/)).not_to exist
+        expect(browser.table(index: 1337)).not_to exist
+        expect(browser.table(xpath: "//table[@id='no_such_id']")).not_to exist
+      end
+
+      it 'checks the tag name when locating by xpath' do
+        expect(browser.table(xpath: '//table//td')).not_to exist
+        expect(browser.table(xpath: '//table')).to exist
+      end
+
+      it "raises TypeError when 'what' argument is invalid" do
+        expect { browser.table(id: 3.14).exists? }.to raise_error(TypeError)
+      end
+    end
+
+    # Other
+    describe '#strings', except: {browser: :safari, reason: 'Safari does not strip text'} do
+      it 'returns a two-dimensional array representation of the table' do
+        expect(browser.table(id: 'inner').strings).to eq [
+          ['Table 2, Row 1, Cell 1',
+           'Table 2, Row 1, Cell 2']
+        ]
+        expect(browser.table(id: 'outer').strings).to eq [
+          ['Table 1, Row 1, Cell 1', 'Table 1, Row 1, Cell 2'],
+          ['Table 1, Row 2, Cell 1',
+           "Table 1, Row 2, Cell 2\nTable 2, Row 1, Cell 1 Table 2, Row 1, Cell 2"],
+          ['Table 1, Row 3, Cell 1', 'Table 1, Row 3, Cell 2']
+        ]
+      end
+    end
+
+    describe '#headers' do
+      it 'returns the first row of a table as the header row' do
+        headers = browser.table(id: 'axis_example').headers
+        expect(headers).to be_a Watir::TableHeaderCellCollection
+        expect(headers.size).to eq 4
+      end
+    end
+
+    describe '#hashes' do
+      it 'returns an Array of Hashes for the common table usage' do
+        array = [
+          {'' => 'March 2008', 'Before income tax' => '', 'Income tax' => '', 'After income tax' => ''},
+          {'' => 'Gregory House', 'Before income tax' => '5 934', 'Income tax' => '1 347',
+           'After income tax' => '4 587'},
+          {'' => 'Hugh Laurie', 'Before income tax' => '6 300', 'Income tax' => '1 479', 'After income tax' => '4 821'},
+          {'' => 'April 2008', 'Before income tax' => '', 'Income tax' => '', 'After income tax' => ''},
+          {'' => 'Gregory House', 'Before income tax' => '5 863', 'Income tax' => '1 331',
+           'After income tax' => '4 532'},
+          {'' => 'Hugh Laurie', 'Before income tax' => '6 252', 'Income tax' => '1 420', 'After income tax' => '4 832'},
+          {'' => 'Sum', 'Before income tax' => '24 349', 'Income tax' => '5 577', 'After income tax' => '18 722'}
+        ]
+        expect(browser.table(id: 'axis_example').hashes).to eq array
+      end
+
+      it 'raises an error if the table could not be parsed' do
+        browser.goto(WatirSpec.url_for('uneven_table.html'))
+
+        expect {
+          browser.table.hashes
+        }.to raise_error('row at index 0 has 2 cells, while header row has 3')
+      end
+    end
+
+    describe '#click' do
+      it "fires the table's onclick event" do
+        browser.table(id: 'inner').click
+        expect(messages).to include('table')
+      end
+    end
+
+    describe '#[]' do
+      it 'returns the nth child row' do
+        expect(browser.table(id: 'outer')[0].id).to eq 'outer_first'
+        expect(browser.table(id: 'inner')[0].id).to eq 'inner_first'
+        expect(browser.table(id: 'outer')[2].id).to eq 'outer_last'
+      end
+    end
+
+    describe '#row' do
+      let(:table) { browser.table(id: 'outer') }
+
+      it 'finds rows belonging to this table' do
+        expect(table.row(id: 'outer_last')).to exist
+        expect(table.row(text: /Table 1, Row 1, Cell 1/)).to exist
+      end
+
+      it 'does not find rows from a nested table' do
+        expect(table.row(id: 'inner_first')).not_to exist
+        expect(table.row(text: /\ATable 2, Row 1, Cell 1 Table 2, Row 1, Cell 2\z/)).not_to exist
+      end
+    end
+
+    describe '#rows' do
+      it 'finds the correct number of rows (excluding nested tables)' do
+        expect(browser.table(id: 'inner').rows.length).to eq 1
+        expect(browser.table(id: 'outer').rows.length).to eq 3
+      end
+
+      it 'finds rows matching the selector' do
+        rows = browser.table(id: 'outer').rows(id: /first|last/)
+
+        expect(rows.first.id).to eq 'outer_first'
+        expect(rows.last.id).to eq 'outer_last'
+      end
+
+      it 'does not find rows from a nested table' do
+        expect(browser.table(id: 'outer').rows(id: 't2_r1_c1').size).to eq 0
+      end
+    end
+
+    describe '#tbody' do
+      it 'returns the correct instance of TableSection' do
+        body = browser.table(index: 0).tbody(id: 'first')
+        expect(body).to be_instance_of(Watir::TableSection)
+        expect(body[0][0].text).to eq 'March 2008'
+      end
+    end
+
+    describe '#tbodys' do
+      it 'returns the correct instance of TableSection' do
+        bodies = browser.table(index: 0).tbodys
+
+        expect(bodies).to be_instance_of(Watir::TableSectionCollection)
+
+        expect(bodies[0].id).to eq 'first'
+        expect(bodies[1].id).to eq 'second'
+      end
+    end
+
+    describe '#each' do
+      it 'allows iterating over the rows in a table' do
+        expect(browser.table(id: 'inner').to_a).to all be_a Watir::Row
+      end
+    end
+
+    context 'when nested' do
+      before do
+        browser.goto(WatirSpec.url_for('nested_tables.html'))
+      end
+
+      it 'returns the correct number of rows under a table element' do
+        tables = browser.div(id: 'table-rows-test').tables(id: /^tbl/)
+        expect(tables.length).to be > 0
+
+        tables.each do |table|
+          expected = Integer(table.data_row_count)
+          actual = table.rows.length
+          browser_count = Integer(table.data_browser_count)
+
+          msg = "expected #{expected} rows, got #{actual} for table id=#{table.id}, browser reported: #{browser_count}"
+          expect(actual).to eql(expected), msg
+        end
+      end
+
+      it 'returns the correct number of cells under a row' do
+        rows = browser.div(id: 'row-cells-test').trs(id: /^row/)
+        expect(rows.length).to be > 0
+
+        rows.each do |row|
+          expected = Integer(row.data_cell_count)
+          actual = row.cells.length
+          browser_count = Integer(row.data_browser_count)
+
+          msg = "expected #{expected} cells, got #{actual} for row id=#{row.id}, browser reported: #{browser_count}"
+          expect(actual).to eql(expected), msg
+        end
+      end
+
+      it 'returns the correct number of rows under a table section' do
+        tbodies = browser.table(id: 'tbody-rows-test').tbodys(id: /^body/)
+        expect(tbodies.length).to be > 0
+
+        tbodies.each do |tbody|
+          expected = Integer(tbody.data_rows_count)
+          actual = tbody.rows.count
+          browser_count = Integer(tbody.data_browser_count)
+
+          msg = "expected #{expected} rows, got #{actual} for tbody id=#{tbody.id}, browser reported: #{browser_count}"
+          expect(actual).to eql(expected), msg
+        end
+      end
+    end
+  end
+end

data/spec/watirspec/elements/tables_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'watirspec_helper'
+
+module Watir
+  describe TableCollection do
+    before do
+      browser.goto(WatirSpec.url_for('tables.html'))
+    end
+
+    describe 'with selectors' do
+      it 'returns the matching elements' do
+        expect(browser.tables(rules: 'groups').to_a).to eq [browser.table(rules: 'groups')]
+      end
+    end
+
+    describe '#length' do
+      it 'returns the number of tables' do
+        expect(browser.tables.length).to eq 4
+      end
+    end
+
+    describe '#[]' do
+      it 'returns the p at the given index' do
+        expect(browser.tables[0].id).to eq 'axis_example'
+        expect(browser.tables[1].id).to eq 'outer'
+        expect(browser.tables[2].id).to eq 'inner'
+      end
+    end
+
+    describe '#each' do
+      it 'iterates through tables correctly' do
+        count = 0
+
+        browser.tables.each_with_index do |t, index|
+          expect(t.id).to eq browser.table(index: index).id
+          count += 1
+        end
+
+        expect(count).to be > 0
+      end
+    end
+  end
+end

data/spec/watirspec/elements/tbody_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'watirspec_helper'
+
+module Watir
+  describe 'TableBody' do
+    before do
+      browser.goto(WatirSpec.url_for('tables.html'))
+    end
+
+    describe '#exists?' do
+      it 'returns true if the table body exists (page context)' do
+        expect(browser.tbody(id: 'first')).to exist
+        expect(browser.tbody(id: /first/)).to exist
+        expect(browser.tbody(index: 0)).to exist
+        expect(browser.tbody(xpath: "//tbody[@id='first']")).to exist
+      end
+
+      it 'returns true if the table body exists (table context)' do
+        expect(browser.table(index: 0).tbody(id: 'first')).to exist
+        expect(browser.table(index: 0).tbody(id: /first/)).to exist
+        expect(browser.table(index: 0).tbody(index: 1)).to exist
+        expect(browser.table(index: 0).tbody(xpath: "//tbody[@id='first']")).to exist
+      end
+
+      it 'returns the first table body if given no args' do
+        expect(browser.table.tbody).to exist
+      end
+
+      it "returns false if the table body doesn't exist (page context)" do
+        expect(browser.tbody(id: 'no_such_id')).not_to exist
+        expect(browser.tbody(id: /no_such_id/)).not_to exist
+        expect(browser.tbody(index: 1337)).not_to exist
+        expect(browser.tbody(xpath: "//tbody[@id='no_such_id']")).not_to exist
+      end
+
+      it "returns false if the table body doesn't exist (table context)" do
+        expect(browser.table(index: 0).tbody(id: 'no_such_id')).not_to exist
+        expect(browser.table(index: 0).tbody(id: /no_such_id/)).not_to exist
+        expect(browser.table(index: 0).tbody(index: 1337)).not_to exist
+        expect(browser.table(index: 0).tbody(xpath: "//tbody[@id='no_such_id']")).not_to exist
+      end
+
+      it "raises TypeError when 'what' argument is invalid" do
+        expect { browser.tbody(id: 3.14).exists? }.to raise_error(TypeError)
+        expect { browser.table(index: 0).tbody(id: 3.14).exists? }.to raise_error(TypeError)
+      end
+    end
+
+    describe '#[]', except: {browser: :safari, reason: 'Safari does not strip text'} do
+      it 'returns the row at the given index (page context)' do
+        expect(browser.tbody(id: 'first')[0].text).to eq 'March 2008'
+        expect(browser.tbody(id: 'first')[1][0].text).to eq 'Gregory House'
+        expect(browser.tbody(id: 'first')[2][0].text).to eq 'Hugh Laurie'
+      end
+
+      it 'returns the row at the given index (table context)' do
+        expect(browser.table(index: 0).tbody(id: 'first')[0].text).to eq 'March 2008'
+        expect(browser.table(index: 0).tbody(id: 'first')[1][0].text).to eq 'Gregory House'
+        expect(browser.table(index: 0).tbody(id: 'first')[2][0].text).to eq 'Hugh Laurie'
+      end
+    end
+
+    describe '#row' do
+      it 'finds the first row matching the selector' do
+        row = browser.tbody(id: 'first').row(id: 'gregory')
+
+        expect(row.tag_name).to eq 'tr'
+        expect(row.id).to eq 'gregory'
+      end
+    end
+
+    describe '#rows' do
+      it 'finds rows matching the selector' do
+        rows = browser.tbody(id: 'first').rows(id: /h$/)
+
+        expect(rows.size).to eq 2
+
+        expect(rows.first.id).to eq 'march'
+        expect(rows.last.id).to eq 'hugh'
+      end
+    end
+
+    describe '#strings' do
+      it 'returns the text of child cells' do
+        expect(browser.tbody(id: 'first').strings).to eq [
+          ['March 2008', '', '', ''],
+          ['Gregory House', '5 934', '1 347', '4 587'],
+          ['Hugh Laurie', '6 300', '1 479', '4 821']
+        ]
+      end
+    end
+  end
+end