watir 6.17.0 → 7.0.0.beta2

data/spec/watirspec/user_editable_spec.rb

@@ -5,34 +5,32 @@ describe Watir::UserEditable do
     browser.goto(WatirSpec.url_for('forms_with_input_elements.html'))
   end
 
-  bug 'incorrectly clears first', :safari do
-    describe '#append' do
-      it 'appends the text to the text field' do
-        browser.text_field(name: 'new_user_occupation').append(' Append This')
-        expect(browser.text_field(name: 'new_user_occupation').value).to eq 'Developer Append This'
-      end
-
-      it 'appends multi-byte characters' do
-        browser.text_field(name: 'new_user_occupation').append(' ijij')
-        expect(browser.text_field(name: 'new_user_occupation').value).to eq 'Developer ijij'
-      end
-
-      it 'raises NotImplementedError if the object is content editable element' do
-        msg = '#append method is not supported with contenteditable element'
-        expect { browser.div(id: 'contenteditable').append('bar') }.to raise_exception(NotImplementedError, msg)
-      end
-
-      it 'raises ObjectReadOnlyException if the object is read only' do
-        expect { browser.text_field(id: 'new_user_code').append('Append This') }.to raise_object_read_only_exception
-      end
-
-      it 'raises ObjectDisabledException if the object is disabled' do
-        expect { browser.text_field(name: 'new_user_species').append('Append This') }.to raise_object_disabled_exception
-      end
-
-      it "raises UnknownObjectException if the object doesn't exist" do
-        expect { browser.text_field(name: 'no_such_name').append('Append This') }.to raise_unknown_object_exception
-      end
+  describe '#append' do
+    it 'appends the text to the text field', except: {browser: :safari, reason: 'incorrectly clears first'} do
+      browser.text_field(name: 'new_user_occupation').append(' Append This')
+      expect(browser.text_field(name: 'new_user_occupation').value).to eq 'Developer Append This'
+    end
+
+    it 'appends multi-byte characters', except: {browser: :safari, reason: 'incorrectly clears first'} do
+      browser.text_field(name: 'new_user_occupation').append(' ijij')
+      expect(browser.text_field(name: 'new_user_occupation').value).to eq 'Developer ijij'
+    end
+
+    it 'raises NotImplementedError if the object is content editable element' do
+      msg = '#append method is not supported with contenteditable element'
+      expect { browser.div(id: 'contenteditable').append('bar') }.to raise_exception(NotImplementedError, msg)
+    end
+
+    it 'raises ObjectReadOnlyException if the object is read only' do
+      expect { browser.text_field(id: 'new_user_code').append('Append This') }.to raise_object_read_only_exception
+    end
+
+    it 'raises ObjectDisabledException if the object is disabled' do
+      expect { browser.text_field(name: 'new_user_species').append('Append This') }.to raise_object_disabled_exception
+    end
+
+    it "raises UnknownObjectException if the object doesn't exist" do
+      expect { browser.text_field(name: 'no_such_name').append('Append This') }.to raise_unknown_object_exception
     end
   end
 

data/spec/watirspec/wait_spec.rb

@@ -1,191 +1,33 @@
 require 'watirspec_helper'
 
-describe Watir::Element do
+describe Watir do
   before do
     browser.goto WatirSpec.url_for('wait.html')
   end
 
-  # TODO: This is deprecated; remove in future version
-  not_compliant_on :relaxed_locate do
-    describe '#when_present' do
-      it 'invokes subsequent method calls when the element becomes present' do
-        browser.a(id: 'show_bar').click
-
-        bar = browser.div(id: 'bar')
-        bar.when_present(2).click
-        expect(bar.text).to eq 'changed'
-      end
-
-      it 'times out when given a block' do
-        expect { browser.div(id: 'bar').when_present(1) {} }.to raise_error(Watir::Wait::TimeoutError)
-      end
-
-      it 'times out when not given a block' do
-        locator = '(\{:id=>"bar", :tag_name=>"div"\}|\{:tag_name=>"div", :id=>"bar"\})'
-        msg = /^timed out after 1 seconds, waiting for #{locator} to become present$/
-        expect { browser.div(id: 'bar').when_present(1).click }.to raise_error(Watir::Wait::TimeoutError, msg)
-      end
-
-      it 'responds to Element methods' do
-        decorator = browser.div.when_present
-
-        expect(decorator).to respond_to(:exist?)
-        expect(decorator).to respond_to(:present?)
-        expect(decorator).to respond_to(:click)
-      end
-
-      it 'delegates present? to element' do
-        Object.class_eval do
-          def present?
-            false
-          end
-        end
-        element = browser.a(id: 'show_bar').when_present(1)
-        expect(element).to be_present
-      end
-
-      it 'processes before calling present?' do
-        browser.a(id: 'show_bar').click
-        expect(browser.div(id: 'bar').when_present.present?).to be true
-      end
-    end
-  end
-
-  compliant_on :relaxed_locate do
-    it 'clicking automatically waits until the element appears' do
-      browser.a(id: 'show_bar').click
-      expect { browser.div(id: 'bar').click }.to_not raise_exception
-      expect(browser.div(id: 'bar').text).to eq 'changed'
-    end
-
-    it "raises exception if the element doesn't appear" do
-      expect { browser.div(id: 'bar').click }.to raise_unknown_object_exception
-    end
-
-    it "raises exception if the element doesn't become enabled" do
-      expect { browser.button(id: 'btn').click }.to raise_object_disabled_exception
-    end
-  end
-
-  not_compliant_on :relaxed_locate do
-    describe '#wait_until &:enabled?' do
-      it 'invokes subsequent method calls when the element becomes enabled' do
-        browser.a(id: 'enable_btn').click
-
-        btn = browser.button(id: 'btn')
-        btn.wait_until(timeout: 2, &:enabled?).click
-        Watir::Wait.while { btn.enabled? }
-        expect(btn.disabled?).to be true
-      end
-
-      it 'times out' do
-        error = Watir::Wait::TimeoutError
-        inspected = '#<Watir::Button: located: true; {:id=>"btn", :tag_name=>"button"}>'
-        message = "timed out after 1 seconds, waiting for true condition on #{inspected}"
-        element = browser.button(id: 'btn')
-        expect { element.wait_until(timeout: 1, &:enabled?).click }.to raise_error(error, message)
-      end
-
-      it 'responds to Element methods' do
-        element = browser.button.wait_until { true }
-
-        expect(element).to respond_to(:exist?)
-        expect(element).to respond_to(:present?)
-        expect(element).to respond_to(:click)
+  describe '#default_timeout' do
+    context 'when no timeout is specified' do
+      it 'is used by Wait#until' do
+        expect { Watir::Wait.until { false } }.to wait_and_raise_timeout_exception(timeout: 1)
       end
 
-      it 'can be chained with #wait_until &:present?' do
-        browser.a(id: 'show_and_enable_btn').click
-        browser.button(id: 'btn2').wait_until(&:present?).wait_until(&:enabled?).click
-
-        expect(browser.button(id: 'btn2')).to exist
-        expect(browser.button(id: 'btn2')).to be_enabled
+      it 'is used by Wait#while' do
+        expect { Watir::Wait.while { true } }.to wait_and_raise_timeout_exception(timeout: 1)
       end
-    end
-  end
-
-  describe '#wait_until_present' do
-    it 'waits until the element appears' do
-      browser.a(id: 'show_bar').click
-      expect {
-        expect { browser.div(id: 'bar').wait_until_present(timeout: 5) }.to_not raise_exception
-      }.to have_deprecated_wait_until_present
-    end
 
-    bug 'Safari does not recognize date type', :safari do
-      it 'waits until the element re-appears' do
-        browser.link(id: 'readd_bar').click
-        expect {
-          expect { browser.div(id: 'bar').wait_until_present }.to_not raise_exception
-        }.to have_deprecated_wait_until_present
+      it 'ensures all checks happen once even if time has expired' do
+        Watir.default_timeout = -1
+        expect { browser.link.click }.to_not raise_exception
+      ensure
+        Watir.default_timeout = 5
       end
     end
-
-    it "times out if the element doesn't appear" do
-      inspected = '#<Watir::Div: located: true; {:id=>"bar", :tag_name=>"div"}>'
-      error = Watir::Wait::TimeoutError
-      message = "timed out after 1 seconds, waiting for #{inspected} to become present"
-
-      expect {
-        expect { browser.div(id: 'bar').wait_until_present(timeout: 1) }.to raise_error(error, message)
-      }.to have_deprecated_wait_until_present
-    end
-
-    it 'uses provided interval' do
-      element = browser.div(id: 'bar')
-      expect(element).to receive(:present?).twice
-
-      expect {
-        expect { element.wait_until_present(timeout: 0.4, interval: 0.2) }.to raise_timeout_exception
-      }.to have_deprecated_wait_until_present
-    end
   end
+end
 
-  describe '#wait_while_present' do
-    it 'waits until the element disappears' do
-      browser.a(id: 'hide_foo').click
-      expect {
-        expect { browser.div(id: 'foo').wait_while_present(timeout: 2) }.to_not raise_exception
-      }.to have_deprecated_wait_while_present
-    end
-
-    it "times out if the element doesn't disappear" do
-      error = Watir::Wait::TimeoutError
-      inspected = '#<Watir::Div: located: true; {:id=>"foo", :tag_name=>"div"}>'
-      message = "timed out after 1 seconds, waiting for #{inspected} not to be present"
-      expect {
-        expect { browser.div(id: 'foo').wait_while_present(timeout: 1) }.to raise_error(error, message)
-      }.to have_deprecated_wait_while_present
-    end
-
-    it 'uses provided interval' do
-      error = Watir::Wait::TimeoutError
-      element = browser.div(id: 'foo')
-      expect(element).to receive(:present?).and_return(true).twice
-
-      expect {
-        expect { element.wait_while_present(timeout: 0.4, interval: 0.2) }.to raise_error(error)
-      }.to have_deprecated_wait_while_present
-    end
-
-    it 'does not error when element goes stale' do
-      element = browser.div(id: 'foo').locate
-
-      allow(element).to receive(:stale?).and_return(false, true)
-
-      browser.a(id: 'hide_foo').click
-      expect {
-        expect { element.wait_while_present(timeout: 1) }.to_not raise_exception
-      }.to have_deprecated_wait_while_present
-    end
-
-    it 'waits until the selector no longer matches' do
-      element = browser.link(name: 'add_select').wait_until(&:exists?)
-      browser.link(id: 'change_select').click
-      expect {
-        expect { element.wait_while_present }.not_to raise_error
-      }.to have_deprecated_wait_while_present
-    end
+describe Watir::Element do
+  before do
+    browser.goto WatirSpec.url_for('wait.html')
   end
 
   describe '#wait_until' do
@@ -292,12 +134,11 @@ describe Watir::Element do
     end
 
     context 'accepts keywords instead of block' do
-      bug 'Safari does not recognize date type', :safari do
-        it 'accepts text keyword' do
-          element = browser.div(id: 'foo')
-          browser.a(id: 'hide_foo').click
-          expect { element.wait_while(text: 'foo') }.to_not raise_exception
-        end
+      it 'accepts text keyword', except: {browser: :safari,
+                                          reason: 'Safari does not recognize date type'} do
+        element = browser.div(id: 'foo')
+        browser.a(id: 'hide_foo').click
+        expect { element.wait_while(text: 'foo') }.to_not raise_exception
       end
 
       it 'accepts regular expression value' do
@@ -363,34 +204,146 @@ describe Watir::Element do
       end
     end
   end
+
+  context 'when acting on an element that is never present' do
+    it 'raises exception after timing out' do
+      element = browser.link(id: 'not_there')
+      expect { element.click }.to wait_and_raise_unknown_object_exception
+    end
+  end
+
+  context 'when acting on an element that is already present' do
+    it 'does not wait' do
+      expect { browser.link.click }.to execute_when_satisfied(max: 1)
+    end
+  end
+
+  context 'when acting on an element that eventually becomes present' do
+    it 'waits until element is present and then takes action' do
+      expect {
+        browser.a(id: 'show_bar').click
+        browser.div(id: 'bar').click
+      }.to execute_when_satisfied(min: 1)
+      expect(browser.div(id: 'bar').text).to eq 'changed'
+    end
+
+    it 'waits until text field present and then takes action' do
+      expect {
+        browser.a(id: 'show_textfield').click
+        browser.text_field(id: 'textfield').set 'Foo'
+      }.to execute_when_satisfied(min: 1)
+    end
+  end
+
+  context 'when acting on a read only text field' do
+    it 'waits and raises read only exception if never becomes writable' do
+      expect { browser.text_field(id: 'writable').set 'foo' }.to wait_and_raise_object_read_only_exception
+    end
+
+    it 'waits until writable' do
+      expect {
+        browser.a(id: 'make-writable').click
+        browser.text_field(id: 'writable').set 'foo'
+      }.to execute_when_satisfied(min: 1)
+    end
+  end
+
+  context 'when acting on a disabled button' do
+    it 'waits and raises exception if it never becomes enabled' do
+      expect { browser.button(id: 'btn').click }.to wait_and_raise_object_disabled_exception
+    end
+
+    it 'waits until enabled' do
+      expect {
+        browser.a(id: 'enable_btn').click
+        browser.button(id: 'btn').click
+      }.to execute_when_satisfied(min: 1)
+    end
+  end
+
+  context 'when acting on an element with a parent' do
+    it 'raises exception after timing out if parent never present' do
+      element = browser.link(id: 'not_there')
+      expect { element.element.click }.to wait_and_raise_unknown_object_exception
+    end
+
+    it 'raises exception after timing out when element from a collection whose parent is never present' do
+      element = browser.link(id: 'not_there')
+      expect { element.elements[2].click }.to wait_and_raise_unknown_object_exception
+    end
+
+    it 'does not wait for parent element to be present when querying child element' do
+      el = browser.element(id: 'not_there').element(id: 'doesnt_matter')
+      expect { el.present? }.to execute_when_satisfied(max: 1)
+    end
+  end
 end
 
-describe Watir do
-  describe '#default_timeout' do
-    before do
-      browser.goto WatirSpec.url_for('wait.html')
+describe Watir::ElementCollection do
+  before do
+    browser.goto WatirSpec.url_for('wait.html')
+  end
+
+  describe '#wait_until' do
+    it 'returns collection' do
+      elements = browser.divs
+      expect(elements.wait_until(&:exist?)).to eq elements
     end
 
-    context 'when no timeout is specified' do
-      it 'is used by Wait#until' do
-        expect { Watir::Wait.until { false } }.to wait_and_raise_timeout_exception(timeout: 1)
-      end
+    it 'times out when waiting for non-empty collection' do
+      expect { browser.divs.wait_until(&:empty?) }.to raise_timeout_exception
+    end
 
-      it 'is used by Wait#while' do
-        expect { Watir::Wait.while { true } }.to wait_and_raise_timeout_exception(timeout: 1)
-      end
+    it 'provides matching collection when exists' do
+      expect {
+        browser.a(id: 'add_foobar').click
+        browser.divs(id: 'foobar').wait_until(&:exists?)
+      }.to execute_when_satisfied(min: 1)
+    end
 
-      it 'is used by Element#wait_until_present' do
-        expect {
-          expect { browser.div(id: 'bar').wait_until_present }.to wait_and_raise_timeout_exception(timeout: 1)
-        }.to have_deprecated_wait_until_present
-      end
+    it 'accepts self in block' do
+      expect {
+        browser.a(id: 'add_foobar').click
+        browser.divs.wait_until { |els| els.size == 7 }
+      }.to execute_when_satisfied(min: 1)
+    end
 
-      it 'is used by Element#wait_while_present' do
-        expect {
-          expect { browser.div(id: 'foo').wait_while_present }.to wait_and_raise_timeout_exception(timeout: 1)
-        }.to have_deprecated_wait_while_present
-      end
+    it 'accepts attributes to evaluate' do
+      expect {
+        browser.a(id: 'add_foobar').click
+        browser.divs.wait_until(size: 7)
+      }.to execute_when_satisfied(min: 1)
+    end
+  end
+
+  describe '#wait_while' do
+    it 'returns collection' do
+      elements = browser.divs
+      expect(elements.wait_while(&:empty?)).to eq elements
+    end
+
+    it 'times out when waiting for non-empty collection' do
+      elements = browser.divs
+      expect { elements.wait_while(&:exists?) }.to raise_timeout_exception
     end
+
+    it 'provides matching collection when exists' do
+      expect {
+        browser.a(id: 'remove_foo').click
+        browser.divs(id: 'foo').wait_while(&:exists?)
+      }.to execute_when_satisfied(min: 1)
+    end
+
+    it 'accepts self in block' do
+      expect {
+        browser.a(id: 'add_foobar').click
+        browser.divs.wait_while { |els| els.size == 6 }
+      }.to execute_when_satisfied(min: 1)
+    end
+  end
+
+  it 'waits for parent element to be present before locating' do
+    els = browser.element(id: /not|there/).elements(id: 'doesnt_matter')
+    expect { els.to_a }.to wait_and_raise_unknown_object_exception
   end
 end