watir 6.10.1 → 6.10.2

data/spec/watirspec/relaxed_locate_spec.rb

@@ -1,99 +1,99 @@
-require "watirspec_helper"
-
-describe 'Watir#relaxed_locate?' do
-  not_compliant_on :not_relaxed_locate do
-    context 'when true' do
-      before :each do
-        browser.goto(WatirSpec.url_for("wait.html"))
-      end
-
-      context 'when acting on an element that is never present' do
-        it 'raises exception after timing out' do
-          begin
-            time_out = 2
-            Watir.default_timeout = time_out
-            element = browser.link(id: 'not_there')
-            start_time = ::Time.now
-            allow($stderr).to receive(:write).twice
-            expect { element.click }.to raise_exception(Watir::Exception::UnknownObjectException)
-            expect(::Time.now - start_time).to be > time_out
-          ensure
-            Watir.default_timeout = 30
-          end
-        end
-      end
-
-      context 'when acting on an element that is already present' do
-        it 'does not wait' do
-          begin
-            Watir.default_timeout = 5
-            start_time = ::Time.now
-            expect { browser.link.click }.to_not raise_exception
-            expect(::Time.now - start_time).to be < 5
-          ensure
-            Watir.default_timeout = 30
-          end
-        end
-      end
-
-      context 'when acting on an element that eventually becomes present' do
-        bug "https://github.com/SeleniumHQ/selenium/issues/4380", %i{remote firefox} do
-          it 'waits until present and then takes action' do
-            begin
-              Watir.default_timeout = 3
-              start_time = ::Time.now
-              browser.a(id: 'show_bar').click
-              expect { browser.div(id: 'bar').click }.to_not raise_exception
-              expect(::Time.now - start_time).to be < 3
-            ensure
-              Watir.default_timeout = 30
-            end
-          end
-        end
-      end
-
-      it 'ensures all checks happen once even if time has expired' do
-        begin
-          Watir.default_timeout = -1
-          expect { browser.link.click }.to_not raise_exception
-        ensure
-          Watir.default_timeout = 30
-        end
-      end
-    end
-  end
-
-  not_compliant_on :relaxed_locate do
-    context 'when false' do
-      before :each do
-        browser.goto(WatirSpec.url_for("wait.html"))
-      end
-
-      context 'when acting on an element that is never present' do
-        it 'raises exception immediately' do
-          begin
-            time_out = 2
-            Watir.default_timeout = time_out
-            element = browser.link(id: 'not_there')
-            start_time = ::Time.now
-            expect { element.click }.to raise_exception(Watir::Exception::UnknownObjectException)
-            expect(::Time.now - start_time).to be < 1
-          ensure
-            Watir.default_timeout = 30
-          end
-        end
-      end
-
-      context 'when acting on an element that eventually becomes present' do
-        it 'raises exception immediately' do
-          start_time = ::Time.now
-          browser.a(id: 'show_bar').click
-
-          expect { browser.div(id: 'bar').click }.to raise_unknown_object_exception
-
-          expect(::Time.now - start_time).to be < 1
-        end
-      end
-    end
-  end
-end
+require "watirspec_helper"
+
+describe 'Watir#relaxed_locate?' do
+  not_compliant_on :not_relaxed_locate do
+    context 'when true' do
+      before :each do
+        browser.goto(WatirSpec.url_for("wait.html"))
+      end
+
+      context 'when acting on an element that is never present' do
+        it 'raises exception after timing out' do
+          begin
+            time_out = 2
+            Watir.default_timeout = time_out
+            element = browser.link(id: 'not_there')
+            start_time = ::Time.now
+            allow($stderr).to receive(:write).twice
+            expect { element.click }.to raise_exception(Watir::Exception::UnknownObjectException)
+            expect(::Time.now - start_time).to be > time_out
+          ensure
+            Watir.default_timeout = 30
+          end
+        end
+      end
+
+      context 'when acting on an element that is already present' do
+        it 'does not wait' do
+          begin
+            Watir.default_timeout = 5
+            start_time = ::Time.now
+            expect { browser.link.click }.to_not raise_exception
+            expect(::Time.now - start_time).to be < 5
+          ensure
+            Watir.default_timeout = 30
+          end
+        end
+      end
+
+      context 'when acting on an element that eventually becomes present' do
+        bug "https://github.com/SeleniumHQ/selenium/issues/4380", %i{remote firefox} do
+          it 'waits until present and then takes action' do
+            begin
+              Watir.default_timeout = 3
+              start_time = ::Time.now
+              browser.a(id: 'show_bar').click
+              expect { browser.div(id: 'bar').click }.to_not raise_exception
+              expect(::Time.now - start_time).to be < 3
+            ensure
+              Watir.default_timeout = 30
+            end
+          end
+        end
+      end
+
+      it 'ensures all checks happen once even if time has expired' do
+        begin
+          Watir.default_timeout = -1
+          expect { browser.link.click }.to_not raise_exception
+        ensure
+          Watir.default_timeout = 30
+        end
+      end
+    end
+  end
+
+  not_compliant_on :relaxed_locate do
+    context 'when false' do
+      before :each do
+        browser.goto(WatirSpec.url_for("wait.html"))
+      end
+
+      context 'when acting on an element that is never present' do
+        it 'raises exception immediately' do
+          begin
+            time_out = 2
+            Watir.default_timeout = time_out
+            element = browser.link(id: 'not_there')
+            start_time = ::Time.now
+            expect { element.click }.to raise_exception(Watir::Exception::UnknownObjectException)
+            expect(::Time.now - start_time).to be < 1
+          ensure
+            Watir.default_timeout = 30
+          end
+        end
+      end
+
+      context 'when acting on an element that eventually becomes present' do
+        it 'raises exception immediately' do
+          start_time = ::Time.now
+          browser.a(id: 'show_bar').click
+
+          expect { browser.div(id: 'bar').click }.to raise_unknown_object_exception
+
+          expect(::Time.now - start_time).to be < 1
+        end
+      end
+    end
+  end
+end

data/spec/watirspec/screenshot_spec.rb

@@ -1,29 +1,29 @@
-require "base64"
-require "watirspec_helper"
-
-describe "Watir::Screenshot" do
-  let(:png_header) { "\211PNG".force_encoding('ASCII-8BIT') }
-
-  describe '#png' do
-    it 'gets png representation of screenshot' do
-      expect(browser.screenshot.png[0..3]).to eq png_header
-    end
-  end
-
-  describe '#base64' do
-    it 'gets base64 representation of screenshot' do
-      image = browser.screenshot.base64
-      expect(Base64.decode64(image)[0..3]).to eq png_header
-    end
-  end
-
-  describe '#save' do
-    it 'saves screenshot to given file' do
-      path = "#{Dir.tmpdir}/test#{Time.now.to_i}.png"
-      expect(File).to_not exist(path)
-      browser.screenshot.save(path)
-      expect(File).to exist(path)
-      expect(File.open(path, "rb") { |io| io.read }[0..3]).to eq png_header
-    end
-  end
-end
+require "base64"
+require "watirspec_helper"
+
+describe "Watir::Screenshot" do
+  let(:png_header) { "\211PNG".force_encoding('ASCII-8BIT') }
+
+  describe '#png' do
+    it 'gets png representation of screenshot' do
+      expect(browser.screenshot.png[0..3]).to eq png_header
+    end
+  end
+
+  describe '#base64' do
+    it 'gets base64 representation of screenshot' do
+      image = browser.screenshot.base64
+      expect(Base64.decode64(image)[0..3]).to eq png_header
+    end
+  end
+
+  describe '#save' do
+    it 'saves screenshot to given file' do
+      path = "#{Dir.tmpdir}/test#{Time.now.to_i}.png"
+      expect(File).to_not exist(path)
+      browser.screenshot.save(path)
+      expect(File).to exist(path)
+      expect(File.open(path, "rb") { |io| io.read }[0..3]).to eq png_header
+    end
+  end
+end

data/spec/watirspec/support/raise_exception_matchers.rb

@@ -1,36 +1,36 @@
-if defined?(RSpec)
-  TIMING_EXCEPTIONS = {
-    raise_unknown_object_exception: Watir::Exception::UnknownObjectException,
-    raise_no_matching_window_exception: Watir::Exception::NoMatchingWindowFoundException,
-    raise_unknown_frame_exception: Watir::Exception::UnknownFrameException,
-    raise_object_disabled_exception: Watir::Exception::ObjectDisabledException,
-    raise_object_read_only_exception: Watir::Exception::ObjectReadOnlyException,
-    raise_no_value_found_exception: Watir::Exception::NoValueFoundException
-  }.freeze
-
-  TIMING_EXCEPTIONS.each do |matcher, exception|
-    RSpec::Matchers.define matcher do |message|
-      match do |actual|
-        original_timeout = Watir.default_timeout
-        Watir.default_timeout = 0
-        begin
-          actual.call
-          false
-        rescue exception => ex
-          raise exception, "expected '#{message}' to be included in: '#{ex.message}'" unless message.nil? || ex.message.include?(message)
-          true
-        ensure
-          Watir.default_timeout = original_timeout
-        end
-      end
-
-      failure_message do |_actual|
-        "expected #{exception} but nothing was raised"
-      end
-
-      def supports_block_expectations?
-        true
-      end
-    end
-  end
-end
+if defined?(RSpec)
+  TIMING_EXCEPTIONS = {
+    raise_unknown_object_exception: Watir::Exception::UnknownObjectException,
+    raise_no_matching_window_exception: Watir::Exception::NoMatchingWindowFoundException,
+    raise_unknown_frame_exception: Watir::Exception::UnknownFrameException,
+    raise_object_disabled_exception: Watir::Exception::ObjectDisabledException,
+    raise_object_read_only_exception: Watir::Exception::ObjectReadOnlyException,
+    raise_no_value_found_exception: Watir::Exception::NoValueFoundException
+  }.freeze
+
+  TIMING_EXCEPTIONS.each do |matcher, exception|
+    RSpec::Matchers.define matcher do |message|
+      match do |actual|
+        original_timeout = Watir.default_timeout
+        Watir.default_timeout = 0
+        begin
+          actual.call
+          false
+        rescue exception => ex
+          raise exception, "expected '#{message}' to be included in: '#{ex.message}'" unless message.nil? || ex.message.include?(message)
+          true
+        ensure
+          Watir.default_timeout = original_timeout
+        end
+      end
+
+      failure_message do |_actual|
+        "expected #{exception} but nothing was raised"
+      end
+
+      def supports_block_expectations?
+        true
+      end
+    end
+  end
+end

data/spec/watirspec/wait_spec.rb

@@ -1,381 +1,381 @@
-require "watirspec_helper"
-
-describe Watir::Wait do
-  describe "#until" do
-    it "waits until the block returns true" do
-      Watir::Wait.until(timeout: 0.5) { @result = true }
-      expect(@result).to be true
-    end
-
-    it "executes block if timeout is zero" do
-      Watir::Wait.until(timeout: 0) { @result = true }
-      expect(@result).to be true
-    end
-
-    it "times out" do
-      expect { Watir::Wait.until(timeout: 0.5) { false } }.to raise_error(Watir::Wait::TimeoutError)
-    end
-
-    it "times out with a custom message" do
-      expect {
-        Watir::Wait.until(timeout: 0.5, message: "oops") { false }
-      }.to raise_error(Watir::Wait::TimeoutError, "timed out after 0.5 seconds, oops")
-    end
-
-    it "uses provided interval" do
-      begin
-        Watir::Wait.until(timeout: 0.4, interval: 0.2) do
-          @result = @result.nil? ? 1 : @result + 1
-          false
-        end
-      rescue Watir::Wait::TimeoutError
-      end
-      expect(@result).to eq 2
-    end
-
-    it "uses timer for waiting" do
-      timer = Watir::Wait.timer
-      expect(timer).to receive(:wait).with(0.5).and_call_original
-      Watir::Wait.until(timeout: 0.5) { true }
-    end
-  end
-
-  describe "#while" do
-    it "waits while the block returns true" do
-      expect(Watir::Wait.while(timeout: 0.5) { false }).to be_nil
-    end
-
-    it "executes block if timeout is zero" do
-      expect(Watir::Wait.while(timeout: 0) { false }).to be_nil
-    end
-
-    it "times out" do
-      expect { Watir::Wait.while(timeout: 0.5) { true } }.to raise_error(Watir::Wait::TimeoutError)
-    end
-
-    it "times out with a custom message" do
-      expect {
-        Watir::Wait.while(timeout: 0.5, message: "oops") { true }
-      }.to raise_error(Watir::Wait::TimeoutError, "timed out after 0.5 seconds, oops")
-    end
-
-    it "uses provided interval" do
-      begin
-        Watir::Wait.while(timeout: 0.4, interval: 0.2) do
-          @result = @result.nil? ? 1 : @result + 1
-          true
-        end
-      rescue Watir::Wait::TimeoutError
-      end
-      expect(@result).to eq 2
-    end
-
-    it "uses timer for waiting" do
-      timer = Watir::Wait.timer
-      expect(timer).to receive(:wait).with(0.5).and_call_original
-      Watir::Wait.while(timeout: 0.5) { false }
-    end
-  end
-
-  describe "#timer" do
-    it "returns default timer" do
-      expect(Watir::Wait.timer).to be_a(Watir::Wait::Timer)
-    end
-  end
-
-  describe "#timer=" do
-    after { Watir::Wait.timer = nil }
-
-    it "changes default timer" do
-      timer = Class.new
-      Watir::Wait.timer = timer
-      expect(Watir::Wait.timer).to eq(timer)
-    end
-  end
-end
-
-describe Watir::Element 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
-        message = /^timed out after 1 seconds, waiting for (\{:id=>"bar", :tag_name=>"div"\}|\{:tag_name=>"div", :id=>"bar"\}) to become present$/
-        expect { browser.div(id: 'bar').when_present(1).click }.to raise_error(Watir::Wait::TimeoutError, message)
-      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: false; {: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)
-      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
-      end
-    end
-  end
-
-  describe "#wait_until_present" do
-    it "waits until the element appears" do
-      browser.a(id: 'show_bar').click
-      expect { browser.div(id: 'bar').wait_until_present(timeout: 5) }.to_not raise_exception
-    end
-
-    it "times out if the element doesn't appear" do
-      inspected = '#<Watir::Div: located: false; {:id=>"bar", :tag_name=>"div"}>'
-      error = Watir::Wait::TimeoutError
-      message = "timed out after 1 seconds, waiting for true condition on #{inspected}"
-
-      expect { browser.div(id: 'bar').wait_until_present(timeout: 1) }.to raise_error(error, message)
-    end
-
-    it "uses provided interval" do
-      element = browser.div(id: 'bar')
-      expect(element).to receive(:present?).twice
-
-      begin
-        element.wait_until_present(timeout: 0.4, interval: 0.2)
-      rescue Watir::Wait::TimeoutError
-      end
-    end
-  end
-
-  describe "#wait_while_present" do
-    it "waits until the element disappears" do
-      browser.a(id: 'hide_foo').click
-      expect { browser.div(id: 'foo').wait_while_present(timeout: 2) }.to_not raise_exception
-    end
-
-    it "times out if the element doesn't disappear" do
-      error = Watir::Wait::TimeoutError
-      inspected = '#<Watir::Div: located: false; {:id=>"foo", :tag_name=>"div"}>'
-      message = "timed out after 1 seconds, waiting for false condition on #{inspected}"
-      expect { browser.div(id: 'foo').wait_while_present(timeout: 1) }.to raise_error(error, message)
-    end
-
-    it "uses provided interval" do
-      element = browser.div(id: 'foo')
-      expect(element).to receive(:present?).twice
-
-      begin
-        element.wait_until_present(timeout: 0.4, interval: 0.2)
-      rescue Watir::Wait::TimeoutError
-      end
-    end
-
-    it "does not error when element goes stale" do
-      element = browser.div(id: 'foo')
-
-      allow(element).to receive(:stale?).and_return(false, true)
-      allow(element.wd).to receive(:displayed?).and_raise(Selenium::WebDriver::Error::StaleElementReferenceError)
-
-      browser.a(id: 'hide_foo').click
-      expect { element.wait_while_present(timeout: 1) }.to_not raise_exception
-    end
-
-    it "waits until the selector no longer matches" do
-      Watir.default_timeout = 1
-      element = browser.link(name: 'add_select').wait_until(&:exists?)
-      begin
-        start_time = ::Time.now
-        browser.link(id: 'change_select').click
-        expect { element.wait_while_present }.not_to raise_error
-      ensure
-        Watir.default_timeout = 30
-      end
-    end
-  end
-
-  describe "#wait_until" do
-    it "returns element for additional actions" do
-      element = browser.div(id: 'foo')
-      expect(element.wait_until(&:exist?)).to eq element
-    end
-
-    it "accepts self in block" do
-      element = browser.div(id: 'bar')
-      browser.a(id: 'show_bar').click
-      expect { element.wait_until { |el| el.text == 'bar' } }.to_not raise_exception
-    end
-
-    it "accepts any values in block" do
-      element = browser.div(id: 'bar')
-      expect { element.wait_until { true } }.to_not raise_exception
-    end
-
-    it "accepts just a timeout parameter" do
-      element = browser.div(id: 'bar')
-      expect { element.wait_until(timeout: 0) { true } }.to_not raise_exception
-    end
-
-    it "accepts just a message parameter" do
-      element = browser.div(id: 'bar')
-      expect { element.wait_until(message: 'no') { true } }.to_not raise_exception
-    end
-
-    it "accepts just an interval parameter" do
-      element = browser.div(id: 'bar')
-      expect { element.wait_until(interval: 0.1) { true } }.to_not raise_exception
-    end
-  end
-
-  describe "#wait_while" do
-    it "returns element for additional actions" do
-      element = browser.div(id: 'foo')
-      browser.a(id: 'hide_foo').click
-      expect(element.wait_while(&:present?)).to eq element
-    end
-
-    not_compliant_on :safari do
-      it "accepts self in block" do
-        element = browser.div(id: 'foo')
-        browser.a(id: 'hide_foo').click
-        expect { element.wait_while { |el| el.text == 'foo' } }.to_not raise_exception
-      end
-    end
-
-    it "accepts any values in block" do
-      element = browser.div(id: 'foo')
-      expect { element.wait_while { false } }.to_not raise_exception
-    end
-
-    it "accepts just a timeout parameter" do
-      element = browser.div(id: 'foo')
-      expect { element.wait_while(timeout: 0) { false } }.to_not raise_exception
-    end
-
-    it "accepts just a message parameter" do
-      element = browser.div(id: 'foo')
-      expect { element.wait_while(message: 'no') { false } }.to_not raise_exception
-    end
-
-    it "accepts just an interval parameter" do
-      element = browser.div(id: 'foo')
-      expect { element.wait_while(interval: 0.1) { false } }.to_not raise_exception
-    end
-  end
-end
-
-describe Watir do
-  describe "#default_timeout" do
-    before do
-      Watir.default_timeout = 1
-
-      browser.goto WatirSpec.url_for("wait.html")
-    end
-
-    after do
-      # Reset the default timeout
-      Watir.default_timeout = 30
-    end
-
-    context "when no timeout is specified" do
-      it "is used by Wait#until" do
-        expect {
-          Watir::Wait.until { false }
-        }.to raise_error(Watir::Wait::TimeoutError)
-      end
-
-      it "is used by Wait#while" do
-        expect {
-          Watir::Wait.while { true }
-        }.to raise_error(Watir::Wait::TimeoutError)
-      end
-
-      it "is used by Element#wait_until_present" do
-        expect {
-          browser.div(id: 'bar').wait_until_present
-        }.to raise_error(Watir::Wait::TimeoutError)
-      end
-
-      it "is used by Element#wait_while_present" do
-        expect {
-          browser.div(id: 'foo').wait_while_present
-        }.to raise_error(Watir::Wait::TimeoutError)
-      end
-    end
-  end
-end
+require "watirspec_helper"
+
+describe Watir::Wait do
+  describe "#until" do
+    it "waits until the block returns true" do
+      Watir::Wait.until(timeout: 0.5) { @result = true }
+      expect(@result).to be true
+    end
+
+    it "executes block if timeout is zero" do
+      Watir::Wait.until(timeout: 0) { @result = true }
+      expect(@result).to be true
+    end
+
+    it "times out" do
+      expect { Watir::Wait.until(timeout: 0.5) { false } }.to raise_error(Watir::Wait::TimeoutError)
+    end
+
+    it "times out with a custom message" do
+      expect {
+        Watir::Wait.until(timeout: 0.5, message: "oops") { false }
+      }.to raise_error(Watir::Wait::TimeoutError, "timed out after 0.5 seconds, oops")
+    end
+
+    it "uses provided interval" do
+      begin
+        Watir::Wait.until(timeout: 0.4, interval: 0.2) do
+          @result = @result.nil? ? 1 : @result + 1
+          false
+        end
+      rescue Watir::Wait::TimeoutError
+      end
+      expect(@result).to eq 2
+    end
+
+    it "uses timer for waiting" do
+      timer = Watir::Wait.timer
+      expect(timer).to receive(:wait).with(0.5).and_call_original
+      Watir::Wait.until(timeout: 0.5) { true }
+    end
+  end
+
+  describe "#while" do
+    it "waits while the block returns true" do
+      expect(Watir::Wait.while(timeout: 0.5) { false }).to be_nil
+    end
+
+    it "executes block if timeout is zero" do
+      expect(Watir::Wait.while(timeout: 0) { false }).to be_nil
+    end
+
+    it "times out" do
+      expect { Watir::Wait.while(timeout: 0.5) { true } }.to raise_error(Watir::Wait::TimeoutError)
+    end
+
+    it "times out with a custom message" do
+      expect {
+        Watir::Wait.while(timeout: 0.5, message: "oops") { true }
+      }.to raise_error(Watir::Wait::TimeoutError, "timed out after 0.5 seconds, oops")
+    end
+
+    it "uses provided interval" do
+      begin
+        Watir::Wait.while(timeout: 0.4, interval: 0.2) do
+          @result = @result.nil? ? 1 : @result + 1
+          true
+        end
+      rescue Watir::Wait::TimeoutError
+      end
+      expect(@result).to eq 2
+    end
+
+    it "uses timer for waiting" do
+      timer = Watir::Wait.timer
+      expect(timer).to receive(:wait).with(0.5).and_call_original
+      Watir::Wait.while(timeout: 0.5) { false }
+    end
+  end
+
+  describe "#timer" do
+    it "returns default timer" do
+      expect(Watir::Wait.timer).to be_a(Watir::Wait::Timer)
+    end
+  end
+
+  describe "#timer=" do
+    after { Watir::Wait.timer = nil }
+
+    it "changes default timer" do
+      timer = Class.new
+      Watir::Wait.timer = timer
+      expect(Watir::Wait.timer).to eq(timer)
+    end
+  end
+end
+
+describe Watir::Element 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
+        message = /^timed out after 1 seconds, waiting for (\{:id=>"bar", :tag_name=>"div"\}|\{:tag_name=>"div", :id=>"bar"\}) to become present$/
+        expect { browser.div(id: 'bar').when_present(1).click }.to raise_error(Watir::Wait::TimeoutError, message)
+      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: false; {: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)
+      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
+      end
+    end
+  end
+
+  describe "#wait_until_present" do
+    it "waits until the element appears" do
+      browser.a(id: 'show_bar').click
+      expect { browser.div(id: 'bar').wait_until_present(timeout: 5) }.to_not raise_exception
+    end
+
+    it "times out if the element doesn't appear" do
+      inspected = '#<Watir::Div: located: false; {:id=>"bar", :tag_name=>"div"}>'
+      error = Watir::Wait::TimeoutError
+      message = "timed out after 1 seconds, waiting for true condition on #{inspected}"
+
+      expect { browser.div(id: 'bar').wait_until_present(timeout: 1) }.to raise_error(error, message)
+    end
+
+    it "uses provided interval" do
+      element = browser.div(id: 'bar')
+      expect(element).to receive(:present?).twice
+
+      begin
+        element.wait_until_present(timeout: 0.4, interval: 0.2)
+      rescue Watir::Wait::TimeoutError
+      end
+    end
+  end
+
+  describe "#wait_while_present" do
+    it "waits until the element disappears" do
+      browser.a(id: 'hide_foo').click
+      expect { browser.div(id: 'foo').wait_while_present(timeout: 2) }.to_not raise_exception
+    end
+
+    it "times out if the element doesn't disappear" do
+      error = Watir::Wait::TimeoutError
+      inspected = '#<Watir::Div: located: false; {:id=>"foo", :tag_name=>"div"}>'
+      message = "timed out after 1 seconds, waiting for false condition on #{inspected}"
+      expect { browser.div(id: 'foo').wait_while_present(timeout: 1) }.to raise_error(error, message)
+    end
+
+    it "uses provided interval" do
+      element = browser.div(id: 'foo')
+      expect(element).to receive(:present?).twice
+
+      begin
+        element.wait_until_present(timeout: 0.4, interval: 0.2)
+      rescue Watir::Wait::TimeoutError
+      end
+    end
+
+    it "does not error when element goes stale" do
+      element = browser.div(id: 'foo')
+
+      allow(element).to receive(:stale?).and_return(false, true)
+      allow(element.wd).to receive(:displayed?).and_raise(Selenium::WebDriver::Error::StaleElementReferenceError)
+
+      browser.a(id: 'hide_foo').click
+      expect { element.wait_while_present(timeout: 1) }.to_not raise_exception
+    end
+
+    it "waits until the selector no longer matches" do
+      Watir.default_timeout = 1
+      element = browser.link(name: 'add_select').wait_until(&:exists?)
+      begin
+        start_time = ::Time.now
+        browser.link(id: 'change_select').click
+        expect { element.wait_while_present }.not_to raise_error
+      ensure
+        Watir.default_timeout = 30
+      end
+    end
+  end
+
+  describe "#wait_until" do
+    it "returns element for additional actions" do
+      element = browser.div(id: 'foo')
+      expect(element.wait_until(&:exist?)).to eq element
+    end
+
+    it "accepts self in block" do
+      element = browser.div(id: 'bar')
+      browser.a(id: 'show_bar').click
+      expect { element.wait_until { |el| el.text == 'bar' } }.to_not raise_exception
+    end
+
+    it "accepts any values in block" do
+      element = browser.div(id: 'bar')
+      expect { element.wait_until { true } }.to_not raise_exception
+    end
+
+    it "accepts just a timeout parameter" do
+      element = browser.div(id: 'bar')
+      expect { element.wait_until(timeout: 0) { true } }.to_not raise_exception
+    end
+
+    it "accepts just a message parameter" do
+      element = browser.div(id: 'bar')
+      expect { element.wait_until(message: 'no') { true } }.to_not raise_exception
+    end
+
+    it "accepts just an interval parameter" do
+      element = browser.div(id: 'bar')
+      expect { element.wait_until(interval: 0.1) { true } }.to_not raise_exception
+    end
+  end
+
+  describe "#wait_while" do
+    it "returns element for additional actions" do
+      element = browser.div(id: 'foo')
+      browser.a(id: 'hide_foo').click
+      expect(element.wait_while(&:present?)).to eq element
+    end
+
+    not_compliant_on :safari do
+      it "accepts self in block" do
+        element = browser.div(id: 'foo')
+        browser.a(id: 'hide_foo').click
+        expect { element.wait_while { |el| el.text == 'foo' } }.to_not raise_exception
+      end
+    end
+
+    it "accepts any values in block" do
+      element = browser.div(id: 'foo')
+      expect { element.wait_while { false } }.to_not raise_exception
+    end
+
+    it "accepts just a timeout parameter" do
+      element = browser.div(id: 'foo')
+      expect { element.wait_while(timeout: 0) { false } }.to_not raise_exception
+    end
+
+    it "accepts just a message parameter" do
+      element = browser.div(id: 'foo')
+      expect { element.wait_while(message: 'no') { false } }.to_not raise_exception
+    end
+
+    it "accepts just an interval parameter" do
+      element = browser.div(id: 'foo')
+      expect { element.wait_while(interval: 0.1) { false } }.to_not raise_exception
+    end
+  end
+end
+
+describe Watir do
+  describe "#default_timeout" do
+    before do
+      Watir.default_timeout = 1
+
+      browser.goto WatirSpec.url_for("wait.html")
+    end
+
+    after do
+      # Reset the default timeout
+      Watir.default_timeout = 30
+    end
+
+    context "when no timeout is specified" do
+      it "is used by Wait#until" do
+        expect {
+          Watir::Wait.until { false }
+        }.to raise_error(Watir::Wait::TimeoutError)
+      end
+
+      it "is used by Wait#while" do
+        expect {
+          Watir::Wait.while { true }
+        }.to raise_error(Watir::Wait::TimeoutError)
+      end
+
+      it "is used by Element#wait_until_present" do
+        expect {
+          browser.div(id: 'bar').wait_until_present
+        }.to raise_error(Watir::Wait::TimeoutError)
+      end
+
+      it "is used by Element#wait_while_present" do
+        expect {
+          browser.div(id: 'foo').wait_while_present
+        }.to raise_error(Watir::Wait::TimeoutError)
+      end
+    end
+  end
+end