watir 7.2.0 → 7.2.1

data/spec/watirspec/elements/select_lists_spec.rb

@@ -2,46 +2,48 @@
 
 require 'watirspec_helper'
 
-describe 'SelectLists' do
-  before :each do
-    browser.goto(WatirSpec.url_for('forms_with_input_elements.html'))
-  end
+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
+    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
-  end
 
-  describe '#length' do
-    it 'returns the correct number of select lists on the page' do
-      expect(browser.select_lists.length).to eq 6
+    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
-  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]).to_not be_multiple
-      expect(browser.select_lists[1]).to be_multiple
+    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
-  end
 
-  describe '#each' do
-    it 'iterates through the select lists correctly' do
-      count = 0
+    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
+        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
+          count += 1
+        end
 
-      expect(count).to be > 0
+        expect(count).to be > 0
+      end
     end
   end
 end

data/spec/watirspec/elements/span_spec.rb

@@ -2,116 +2,118 @@
 
 require 'watirspec_helper'
 
-describe 'Span' do
-  before :each 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')).to_not exist
-      expect(browser.span(id: /no_such_id/)).to_not exist
-      expect(browser.span(text: 'no_such_text')).to_not exist
-      expect(browser.span(text: /no_such_text/)).to_not exist
-      expect(browser.span(class: 'no_such_class')).to_not exist
-      expect(browser.span(class: /no_such_class/)).to_not exist
-      expect(browser.span(index: 1337)).to_not exist
-      expect(browser.span(xpath: "//span[@id='no_such_id']")).to_not 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).to_not 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
+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

@@ -2,39 +2,41 @@
 
 require 'watirspec_helper'
 
-describe 'Spans' do
-  before :each do
-    browser.goto(WatirSpec.url_for('non_control_elements.html'))
-  end
+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')]
+    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
-  end
 
-  describe '#length' do
-    it 'returns the number of spans' do
-      expect(browser.spans.length).to eq 8
+    describe '#length' do
+      it 'returns the number of spans' do
+        expect(browser.spans.length).to eq 8
+      end
     end
-  end
 
-  describe '#[]' do
-    it 'returns the p at the given index' do
-      expect(browser.spans[0].id).to eq 'lead'
+    describe '#[]' do
+      it 'returns the p at the given index' do
+        expect(browser.spans[0].id).to eq 'lead'
+      end
     end
-  end
 
-  describe '#each' do
-    it 'iterates through spans correctly' do
-      count = 0
+    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
+        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
+        expect(count).to be > 0
+      end
     end
   end
 end

data/spec/watirspec/elements/strong_spec.rb

@@ -2,77 +2,77 @@
 
 require 'watirspec_helper'
 
-describe 'Strong' do
-  before :each 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
+module Watir
+  describe 'Strong' do
+    before do
+      browser.goto(WatirSpec.url_for('non_control_elements.html'))
     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
+    # 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 'returns the first strong if given no args' do
-      expect(browser.strong).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 false if the element doesn't exist" do
-      expect(browser.strong(id: 'no_such_id')).to_not exist
-      expect(browser.strong(id: /no_such_id/)).to_not exist
-      expect(browser.strong(text: 'no_such_text')).to_not exist
-      expect(browser.strong(text: /no_such_text/)).to_not exist
-      expect(browser.strong(class: 'no_such_class')).to_not exist
-      expect(browser.strong(class: /no_such_class/)).to_not exist
-      expect(browser.strong(index: 1337)).to_not exist
-      expect(browser.strong(xpath: "//strong[@id='no_such_id']")).to_not exist
-    end
+      it 'returns the first strong if given no args' do
+        expect(browser.strong).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
+      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
 
-  # Attribute methods
-  describe '#id' do
-    it 'returns the id attribute' do
-      expect(browser.strong(index: 0).id).to eq 'descartes'
+      it "raises TypeError when 'what' argument is invalid" do
+        expect { browser.strong(id: 3.14).exists? }.to raise_error(TypeError)
+      end
     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
+    # Attribute methods
+    describe '#id' do
+      it 'returns the id attribute' do
+        expect(browser.strong(index: 0).id).to eq 'descartes'
+      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.'
+      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
 
-    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
+    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
-  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)
+    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
-
-  # Other
 end

data/spec/watirspec/elements/strongs_spec.rb

@@ -2,42 +2,44 @@
 
 require 'watirspec_helper'
 
-describe 'Strongs' do
-  before :each do
-    browser.goto(WatirSpec.url_for('non_control_elements.html'))
-  end
+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')]
+    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
-  end
 
-  describe '#length' do
-    it 'returns the number of divs' do
-      expect(browser.strongs.length).to eq 2
+    describe '#length' do
+      it 'returns the number of divs' do
+        expect(browser.strongs.length).to eq 2
+      end
     end
-  end
 
-  describe '#[]' do
-    it 'returns the div at the given index' do
-      expect(browser.strongs[0].id).to eq 'descartes'
+    describe '#[]' do
+      it 'returns the div at the given index' do
+        expect(browser.strongs[0].id).to eq 'descartes'
+      end
     end
-  end
 
-  describe '#each' do
-    it 'iterates through divs correctly' do
-      count = 0
+    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
+        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
+          count += 1
+        end
 
-      expect(count).to be > 0
+        expect(count).to be > 0
+      end
     end
   end
 end