watir 6.14.0 → 6.15.0

data/spec/unit/logger_spec.rb

@@ -24,6 +24,11 @@ module Watir
       expect(Watir.logger.level).to eq(1)
     end
 
+    it 'allows to change level with integer' do
+      Watir.logger.level = 3
+      expect(Watir.logger.level).to eq(3)
+    end
+
     it 'outputs to stdout by default' do
       expect { Watir.logger.warn('message') }.to output(/WARN Watir message/).to_stdout_from_any_process
     end

data/spec/watirspec/adjacent_spec.rb

@@ -17,13 +17,13 @@ describe 'Adjacent Elements' do
     end
 
     it 'accepts tag_name argument' do
-      expect(browser.div(id: 'first_sibling').parent(tag_name: :div).id).to eq 'parent'
-      expect(browser.div(id: 'first_sibling').parent(tag_name: :div)).to be_a Watir::Div
+      expect(browser.div(id: 'first_sibling').parent(tag_name: 'div').id).to eq 'parent'
+      expect(browser.div(id: 'first_sibling').parent(tag_name: 'div')).to be_a Watir::Div
     end
 
     it 'accepts custom tag_name argument' do
-      expect(browser.div(id: 'regular_child').parent(tag_name: :grandelement).id).to eq 'custom_grandparent'
-      expect(browser.div(id: 'regular_child').parent(tag_name: :grandelement)).to be_a Watir::HTMLElement
+      expect(browser.div(id: 'regular_child').parent(tag_name: 'grandelement').id).to eq 'custom_grandparent'
+      expect(browser.div(id: 'regular_child').parent(tag_name: 'grandelement')).to be_a Watir::HTMLElement
     end
 
     it 'accepts class_name argument' do
@@ -31,8 +31,8 @@ describe 'Adjacent Elements' do
     end
 
     it 'accepts index and tag_name arguments' do
-      expect(browser.div(id: 'first_sibling').parent(tag_name: :div, index: 1).id).to eq 'grandparent'
-      expect(browser.div(id: 'first_sibling').parent(tag_name: :div, index: 1)).to be_a Watir::Div
+      expect(browser.div(id: 'first_sibling').parent(tag_name: 'div', index: 1).id).to eq 'grandparent'
+      expect(browser.div(id: 'first_sibling').parent(tag_name: 'div', index: 1)).to be_a Watir::Div
     end
 
     it 'does not error when no parent element of an index exists' do
@@ -40,7 +40,7 @@ describe 'Adjacent Elements' do
     end
 
     it 'does not error when no parent element of a tag_name exists' do
-      expect(browser.div(id: 'first_sibling').parent(tag_name: :table)).to_not exist
+      expect(browser.div(id: 'first_sibling').parent(tag_name: 'table')).to_not exist
     end
   end
 
@@ -51,13 +51,13 @@ describe 'Adjacent Elements' do
     end
 
     it 'accepts a tag name argument' do
-      siblings = browser.div(id: 'second_sibling').siblings(tag_name: :div)
+      siblings = browser.div(id: 'second_sibling').siblings(tag_name: 'div')
       expect(siblings.size).to eq 3
       expect(siblings.all? { |sib| sib.is_a? Watir::Div }).to eq true
     end
 
     it 'accepts custom tag name argument' do
-      siblings = browser.div(id: 'regular_child').siblings(tag_name: :childelement)
+      siblings = browser.div(id: 'regular_child').siblings(tag_name: 'childelement')
       expect(siblings.size).to eq 3
       expect(siblings.all? { |sib| sib.is_a? Watir::HTMLElement }).to eq true
     end
@@ -83,8 +83,8 @@ describe 'Adjacent Elements' do
     end
 
     it 'accepts tag_name argument' do
-      expect(browser.div(id: 'first_sibling').following_sibling(tag_name: :div).id).to eq 'second_sibling'
-      expect(browser.div(id: 'first_sibling').following_sibling(tag_name: :div)).to be_a Watir::Div
+      expect(browser.div(id: 'first_sibling').following_sibling(tag_name: 'div').id).to eq 'second_sibling'
+      expect(browser.div(id: 'first_sibling').following_sibling(tag_name: 'div')).to be_a Watir::Div
     end
 
     it 'accepts class_name argument' do
@@ -92,16 +92,16 @@ describe 'Adjacent Elements' do
     end
 
     it 'accepts index and tag_name arguments' do
-      expect(browser.div(id: 'first_sibling').following_sibling(tag_name: :div, index: 1).id).to eq 'third_sibling'
-      expect(browser.div(id: 'first_sibling').following_sibling(tag_name: :div, index: 1)).to be_a Watir::Div
+      expect(browser.div(id: 'first_sibling').following_sibling(tag_name: 'div', index: 1).id).to eq 'third_sibling'
+      expect(browser.div(id: 'first_sibling').following_sibling(tag_name: 'div', index: 1)).to be_a Watir::Div
     end
 
     it 'accepts text as Regexp' do
-      expect(browser.div(id: 'first_sibling').following_sibling(text: /t/).id).to eq 'third_sibling'
+      expect(browser.div(id: 'first_sibling').following_sibling(text: /T/).id).to eq 'third_sibling'
     end
 
     it 'accepts text as String' do
-      expect(browser.div(id: 'first_sibling').following_sibling(text: 'text').id).to eq 'third_sibling'
+      expect(browser.div(id: 'first_sibling').following_sibling(text: 'Third').id).to eq 'third_sibling'
     end
 
     it 'does not error when no next sibling of an index exists' do
@@ -109,7 +109,7 @@ describe 'Adjacent Elements' do
     end
 
     it 'does not error when no next sibling of a tag_name exists' do
-      expect(browser.div(id: 'first_sibling').following_sibling(tag_name: :table)).to_not exist
+      expect(browser.div(id: 'first_sibling').following_sibling(tag_name: 'table')).to_not exist
     end
   end
 
@@ -120,8 +120,8 @@ describe 'Adjacent Elements' do
     end
 
     it 'accepts tag_name argument' do
-      expect(browser.div(id: 'second_sibling').following_siblings(tag_name: :div).size).to eq 1
-      expect(browser.div(id: 'second_sibling').following_siblings(tag_name: :div).first).to be_a Watir::Div
+      expect(browser.div(id: 'second_sibling').following_siblings(tag_name: 'div').size).to eq 1
+      expect(browser.div(id: 'second_sibling').following_siblings(tag_name: 'div').first).to be_a Watir::Div
     end
 
     it 'accepts class_name argument for single class' do
@@ -147,8 +147,8 @@ describe 'Adjacent Elements' do
     end
 
     it 'accepts tag_name argument' do
-      expect(browser.div(id: 'third_sibling').previous_sibling(tag_name: :div).id).to eq 'second_sibling'
-      expect(browser.div(id: 'third_sibling').previous_sibling(tag_name: :div)).to be_a Watir::Div
+      expect(browser.div(id: 'third_sibling').previous_sibling(tag_name: 'div').id).to eq 'second_sibling'
+      expect(browser.div(id: 'third_sibling').previous_sibling(tag_name: 'div')).to be_a Watir::Div
     end
 
     it 'accepts class_name argument' do
@@ -156,8 +156,8 @@ describe 'Adjacent Elements' do
     end
 
     it 'accepts index and tag_name arguments' do
-      expect(browser.div(id: 'third_sibling').previous_sibling(tag_name: :div, index: 1).id).to eq 'first_sibling'
-      expect(browser.div(id: 'third_sibling').previous_sibling(tag_name: :div, index: 1)).to be_a Watir::Div
+      expect(browser.div(id: 'third_sibling').previous_sibling(tag_name: 'div', index: 1).id).to eq 'first_sibling'
+      expect(browser.div(id: 'third_sibling').previous_sibling(tag_name: 'div', index: 1)).to be_a Watir::Div
     end
 
     it 'does not error when no next sibling of an index exists' do
@@ -165,7 +165,7 @@ describe 'Adjacent Elements' do
     end
 
     it 'does not error when no next sibling of a tag_name exists' do
-      expect(browser.div(id: 'third_sibling').previous_sibling(tag_name: :table)).to_not exist
+      expect(browser.div(id: 'third_sibling').previous_sibling(tag_name: 'table')).to_not exist
     end
   end
 
@@ -176,8 +176,8 @@ describe 'Adjacent Elements' do
     end
 
     it 'accepts tag_name argument' do
-      expect(browser.div(id: 'second_sibling').previous_siblings(tag_name: :div).size).to eq 1
-      expect(browser.div(id: 'second_sibling').previous_siblings(tag_name: :div).first).to be_a Watir::Div
+      expect(browser.div(id: 'second_sibling').previous_siblings(tag_name: 'div').size).to eq 1
+      expect(browser.div(id: 'second_sibling').previous_siblings(tag_name: 'div').first).to be_a Watir::Div
     end
 
     it 'accepts class_name argument' do
@@ -198,13 +198,13 @@ describe 'Adjacent Elements' do
     end
 
     it 'accepts tag_name argument' do
-      expect(browser.div(id: 'parent').child(tag_name: :span).id).to eq 'between_siblings1'
-      expect(browser.div(id: 'parent').child(tag_name: :span)).to be_a Watir::Span
+      expect(browser.div(id: 'parent').child(tag_name: 'span').id).to eq 'between_siblings1'
+      expect(browser.div(id: 'parent').child(tag_name: 'span')).to be_a Watir::Span
     end
 
     it 'accepts custom tag_name argument' do
-      expect(browser.element(id: 'custom_parent').child(tag_name: :childelement).id).to eq 'custom_child'
-      expect(browser.element(id: 'custom_parent').child(tag_name: :childelement)).to be_a Watir::HTMLElement
+      expect(browser.element(id: 'custom_parent').child(tag_name: 'childelement').id).to eq 'custom_child'
+      expect(browser.element(id: 'custom_parent').child(tag_name: 'childelement')).to be_a Watir::HTMLElement
     end
 
     it 'accepts class_name argument' do
@@ -212,8 +212,8 @@ describe 'Adjacent Elements' do
     end
 
     it 'accepts index and tag_name arguments' do
-      expect(browser.div(id: 'parent').child(tag_name: :div, index: 1).id).to eq 'second_sibling'
-      expect(browser.div(id: 'parent').child(tag_name: :div, index: 1)).to be_a Watir::Div
+      expect(browser.div(id: 'parent').child(tag_name: 'div', index: 1).id).to eq 'second_sibling'
+      expect(browser.div(id: 'parent').child(tag_name: 'div', index: 1)).to be_a Watir::Div
     end
 
     it 'does not error when no next sibling of an index exists' do
@@ -221,7 +221,7 @@ describe 'Adjacent Elements' do
     end
 
     it 'does not error when no next sibling of a tag_name exists' do
-      expect(browser.div(id: 'parent').child(tag_name: :table)).to_not exist
+      expect(browser.div(id: 'parent').child(tag_name: 'table')).to_not exist
     end
   end
 
@@ -232,13 +232,13 @@ describe 'Adjacent Elements' do
     end
 
     it 'accepts tag_name argument' do
-      children = browser.div(id: 'parent').children(tag_name: :div)
+      children = browser.div(id: 'parent').children(tag_name: 'div')
       expect(children.size).to eq 3
       expect(children.all? { |child| child.is_a? Watir::Div }).to eq true
     end
 
     it 'accepts custom tag_name argument' do
-      children = browser.element(id: 'custom_parent').children(tag_name: :childelement)
+      children = browser.element(id: 'custom_parent').children(tag_name: 'childelement')
       expect(children.size).to eq 3
       expect(children.all? { |child| child.is_a? Watir::HTMLElement }).to eq true
     end

data/spec/watirspec/after_hooks_spec.rb

@@ -11,6 +11,7 @@ describe 'Browser::AfterHooks' do
       proc = proc { |browser| output << browser.text }
 
       begin
+        browser.alert.dismiss if browser.alert.exists?
         browser.after_hooks.add(proc)
         browser.goto(WatirSpec.url_for('non_control_elements.html'))
 
@@ -19,6 +20,18 @@ describe 'Browser::AfterHooks' do
         browser.after_hooks.delete(proc)
       end
     end
+
+    it 'runs the given block on each page load' do
+      output = ''
+      begin
+        browser.after_hooks.add { |browser| output << browser.text }
+        browser.goto(WatirSpec.url_for('non_control_elements.html'))
+
+        expect(output).to include('Dubito, ergo cogito, ergo sum')
+      ensure
+        browser.after_hooks.delete browser.after_hooks[0]
+      end
+    end
   end
 
   describe '#delete' do
@@ -125,58 +138,88 @@ describe 'Browser::AfterHooks' do
     end
 
     not_compliant_on :safari, :headless do
-      it 'does not run error checks with alert present' do
-        browser.goto WatirSpec.url_for('alerts.html')
-
-        @page_after_hook = proc { @yield = browser.title == 'Alerts' }
-        browser.after_hooks.add @page_after_hook
+      bug 'chromedriver 2.43 https://bugs.chromium.org/p/chromedriver/issues/detail?id=2615', :chrome do
+        it 'does not run error checks with alert present' do
+          browser.goto WatirSpec.url_for('alerts.html')
 
-        browser.button(id: 'alert').click
-        expect(@yield).to be_nil
+          @page_after_hook = proc { @yield = browser.title == 'Alerts' }
+          browser.after_hooks.add @page_after_hook
 
-        browser.alert.ok
-        expect(@yield).to eq true
-      end
-    end
+          browser.button(id: 'alert').click
+          expect(@yield).to be_nil
 
-    not_compliant_on :headless do
-      it 'does not raise error when running error checks using #after_hooks#without with alert present' do
-        url = WatirSpec.url_for('alerts.html')
-        @page_after_hook = proc { browser.url }
-        browser.after_hooks.add @page_after_hook
-        browser.goto url
-        expect { browser.after_hooks.without { browser.button(id: 'alert').click } }.to_not raise_error
-        browser.alert.ok
+          browser.alert.ok
+          expect(@yield).to eq true
+        end
       end
     end
 
     not_compliant_on :headless do
-      it 'does not raise error if no error checks are defined with alert present' do
-        url = WatirSpec.url_for('alerts.html')
-        @page_after_hook = proc { browser.url }
-        browser.after_hooks.add @page_after_hook
-        browser.goto url
-        browser.after_hooks.delete @page_after_hook
-        expect { browser.button(id: 'alert').click }.to_not raise_error
-        browser.alert.ok
+      bug 'chromedriver 2.43 https://bugs.chromium.org/p/chromedriver/issues/detail?id=2615', :chrome do
+        it 'does not raise error when running error checks using #after_hooks#without with alert present' do
+          url = WatirSpec.url_for('alerts.html')
+          @page_after_hook = proc { browser.url }
+          browser.after_hooks.add @page_after_hook
+          browser.goto url
+          expect { browser.after_hooks.without { browser.button(id: 'alert').click } }.to_not raise_error
+          browser.alert.ok
+        end
       end
     end
 
-    bug 'https://bugzilla.mozilla.org/show_bug.cgi?id=1223277', :firefox do
+    bug 'chromedriver 2.43 https://bugs.chromium.org/p/chromedriver/issues/detail?id=2615', :chrome do
       not_compliant_on :headless do
-        it 'does not raise error when running error checks on closed window' do
-          url = WatirSpec.url_for('window_switching.html')
+        it 'does not raise error if no error checks are defined with alert present' do
+          url = WatirSpec.url_for('alerts.html')
           @page_after_hook = proc { browser.url }
           browser.after_hooks.add @page_after_hook
           browser.goto url
-          browser.a(id: 'open').click
+          browser.after_hooks.delete @page_after_hook
+          expect { browser.button(id: 'alert').click }.to_not raise_error
+          browser.alert.ok
+        end
+      end
+    end
 
-          window = browser.window(title: 'closeable window')
-          window.use
-          expect { browser.a(id: 'close').click }.to_not raise_error
-          browser.original_window.use
+    bug 'chromedriver 2.43 https://bugs.chromium.org/p/chromedriver/issues/detail?id=2615', :chrome do
+      bug 'https://bugzilla.mozilla.org/show_bug.cgi?id=1223277', :firefox do
+        not_compliant_on :headless do
+          it 'does not raise error when running error checks on closed window' do
+            url = WatirSpec.url_for('window_switching.html')
+            @page_after_hook = proc { browser.url }
+            browser.after_hooks.add @page_after_hook
+            browser.goto url
+            browser.a(id: 'open').click
+
+            window = browser.window(title: 'closeable window')
+            window.use
+            expect { browser.a(id: 'close').click }.to_not raise_error
+            browser.original_window.use
+          end
         end
       end
     end
   end
+
+  describe '#length' do
+    it 'provides the number of after hooks' do
+      hook = proc { true }
+      begin
+        4.times { browser.after_hooks.add(hook) }
+        expect(browser.after_hooks.length).to eq 4
+      ensure
+        4.times { browser.after_hooks.delete(hook) }
+      end
+    end
+  end
+
+  describe '#[]' do
+    it 'returns the after hook at the provided index' do
+      hook1 = proc { true }
+      hook2 = proc { false }
+      browser.after_hooks.add(hook1)
+      browser.after_hooks.add(hook2)
+      expect(browser.after_hooks[1]).to eq hook2
+    end
+  end
 end

data/spec/watirspec/alert_spec.rb

@@ -10,6 +10,16 @@ not_compliant_on :headless do
       browser.alert.ok if browser.alert.exists?
     end
 
+    not_compliant_on :not_relaxed_locate do
+      context 'Relaxed Waits' do
+        context 'when acting on an alert' do
+          it 'raises exception after timing out' do
+            expect { browser.alert.text }.to wait_and_raise_unknown_object_exception
+          end
+        end
+      end
+    end
+
     context 'alert' do
       describe '#text' do
         it 'returns text of alert' do

data/spec/watirspec/browser_spec.rb

@@ -381,7 +381,7 @@ describe 'Browser' do
         browser.span(class: 'footer').click
         expect(browser.span(class: 'footer').text).to include('Javascript')
         browser.refresh
-        browser.span(class: 'footer').wait_until_present
+        browser.span(class: 'footer').wait_until(&:present?)
         expect(browser.span(class: 'footer').text).to_not include('Javascript')
       end
     end
@@ -508,6 +508,32 @@ describe 'Browser' do
     end
   end
 
+  describe '#wait' do
+    # The only way to get engage this method is with page load strategy set to "none"
+    # Chrome will be blocking on document ready state because it does not yet support page load strategy
+    # This spec is both mocking out the response and demonstrating the necessary settings for it to be meaningful
+    not_compliant_on :chrome do
+      it 'waits for document ready state to be complete' do
+        @original = WatirSpec.implementation.clone
+        browser.close
+        @opts = WatirSpec.implementation.browser_args.last
+
+        @opts[:page_load_strategy] = 'none'
+        browser = WatirSpec.new_browser
+
+        start_time = Time.now
+        allow(browser).to receive(:ready_state) { Time.now < start_time + 3 ? 'loading' : 'complete' }
+        expect(browser.ready_state).to eq 'loading'
+        browser.wait(20)
+        expect(browser.ready_state).to eq 'complete'
+
+        browser.close
+        WatirSpec.implementation = @original.clone
+        $browser = WatirSpec.new_browser
+      end
+    end
+  end
+
   describe '#inspect' do
     it 'works even if browser is closed' do
       expect(browser).to receive(:url).and_raise(Errno::ECONNREFUSED)

data/spec/watirspec/element_hidden_spec.rb

@@ -69,5 +69,11 @@ describe Watir::Locators::Element::Locator do
         expect(elements.size).to eq 3
       end
     end
+
+    it 'raises exception when value is not Boolean' do
+      element = browser.body.element(visible: 'true')
+      msg = 'expected boolean, got "true":String'
+      expect { element.exists? }.to raise_exception(TypeError, msg)
+    end
   end
 end

data/spec/watirspec/elements/button_spec.rb

@@ -94,16 +94,6 @@ describe 'Button' do
   end
 
   # Attribute methods
-  describe '#class_name' do
-    it 'returns the class name of the button' do
-      expect(browser.button(name: 'new_user_image').class_name).to eq 'image'
-    end
-
-    it 'returns an empty string if the button has no class name' do
-      expect(browser.button(name: 'new_user_submit').class_name).to eq ''
-    end
-  end
-
   describe '#id' do
     it 'returns the id if the button exists' do
       expect(browser.button(index: 0).id).to eq 'new_user_submit'
@@ -190,13 +180,17 @@ describe 'Button' do
   end
 
   describe '#text' do
-    it 'returns the text of the button' do
+    it 'returns the text of an input button' do
       expect(browser.button(index: 0).text).to eq 'Submit'
       expect(browser.button(index: 1).text).to eq 'Reset'
       expect(browser.button(index: 2).text).to eq 'Button'
       expect(browser.button(index: 3).text).to eq 'Preview'
     end
 
+    it 'returns the text of a button element' do
+      expect(browser.button(name: 'new_user_button_2').text).to eq 'Button 2'
+    end
+
     it 'raises UnknownObjectException if the element does not exist' do
       expect { browser.button(id: 'no_such_id').text }.to raise_unknown_object_exception
     end