watir 1.4.1 → 7.3.0

data/spec/watirspec/scroll_spec.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require 'watirspec_helper'
+
+module Watir
+  describe Scrolling do
+    before do
+      browser.goto(WatirSpec.url_for('scroll.html'))
+      pause
+    end
+
+    def top_centered_viewport
+      browser.execute_script('return (window.innerHeight - document.body.scrollHeight)/2;')
+    end
+
+    def current_top
+      browser.execute_script('return document.body.getBoundingClientRect().top;')
+    end
+
+    context 'when scrolling Browser' do
+      describe '#to' do
+        it 'scrolls to the top of the page' do
+          browser.scroll.to :bottom
+          expect(browser.div(id: 'top')).not_to be_in_viewport
+          browser.scroll.to :top
+          expect(browser.div(id: 'top')).to be_in_viewport
+        end
+
+        it 'scrolls to the center of the page' do
+          browser.scroll.to :center
+          viewport_top = browser.execute_script('return document.body.getBoundingClientRect().top;')
+
+          expect(viewport_top).to be_within(1).of(top_centered_viewport)
+        end
+
+        it 'scrolls to the bottom of the page' do
+          expect(browser.div(id: 'bottom')).not_to be_in_viewport
+          browser.scroll.to :bottom
+          expect(browser.div(id: 'bottom')).to be_in_viewport
+        end
+
+        it 'scrolls to coordinates' do
+          element = browser.div(id: 'center')
+          location = element.location
+          browser.scroll.to [location.x, location.y]
+          expect(element).to be_in_viewport
+        end
+
+        it 'raises error when scroll point is not valid' do
+          expect { browser.scroll.to(:blah) }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe '#by' do
+        before do
+          browser.scroll.to :top
+          pause
+        end
+
+        it 'offset from top' do
+          initial_top = current_top
+          scroll_by = top_centered_viewport.round
+          browser.scroll.by(0, -scroll_by)
+          pause
+          puts "scroll by #{scroll_by}"
+          puts "initial top #{initial_top}"
+          puts "current top #{current_top}"
+          expect(current_top).to be_within(1).of(scroll_by + initial_top)
+        end
+
+        it 'offset from bottom' do
+          initial_top = current_top
+          browser.scroll.to :bottom
+          scroll_by = top_centered_viewport
+          browser.scroll.by(0, scroll_by)
+          pause
+          expect(current_top).to be_within(1).of(scroll_by + initial_top)
+        end
+      end
+
+      describe '#from' do
+        it 'scrolls by given amount with offset', except: {browser: :ie, reason: 'Not implemented'} do
+          browser.goto(WatirSpec.url_for('scroll_nested.html'))
+
+          browser.scroll.from(10, 10).by(0, 225)
+
+          expect(in_viewport?(browser.iframe.checkbox(name: 'scroll_checkbox'))).to be true
+        end
+      end
+    end
+
+    context 'when scrolling Element' do
+      describe '#to' do
+        it 'scrolls element into view (viewport)',
+           except: [{browser: %i[firefox safari], reason: 'incorrect MoveTargetOutOfBoundsError'},
+                    {browser: :ie, reason: 'Not implemented'}] do
+          browser.goto(WatirSpec.url_for('scroll_nested_offscreen.html'))
+          iframe = browser.iframe
+
+          expect(in_viewport?(iframe)).to be false
+
+          iframe.scroll.to(:viewport)
+
+          expect(in_viewport?(iframe)).to be true
+        end
+
+        it 'scrolls to element (top) by default' do
+          element = browser.div(id: 'center')
+          element.scroll.to
+
+          element_top = browser.execute_script('return arguments[0].getBoundingClientRect().top', element)
+          expect(element_top).to be_within(1).of(0)
+        end
+
+        it 'scrolls to element (center)' do
+          element = browser.div(id: 'center')
+          element.scroll.to :center
+
+          element_rect = browser.execute_script('return arguments[0].getBoundingClientRect()', element)
+
+          expect(element_rect['top']).to eq(element_rect['bottom'] - element_rect['height'])
+        end
+
+        it 'scrolls to element (bottom)' do
+          element = browser.div(id: 'center')
+          element.scroll.to :bottom
+
+          element_bottom = browser.execute_script('return arguments[0].getBoundingClientRect().bottom', element)
+          window_height = browser.execute_script('return window.innerHeight')
+
+          expect(element_bottom).to be_within(1).of(window_height)
+        end
+
+        it 'scrolls to element multiple times' do
+          2.times do
+            element = browser.div(id: 'center')
+            element.scroll.to(:center)
+
+            element_rect = browser.execute_script('return arguments[0].getBoundingClientRect()', element)
+
+            expect(element_rect['top']).to eq(element_rect['bottom'] - element_rect['height'])
+          end
+        end
+
+        it 'raises error when scroll param is not valid' do
+          expect { browser.div(id: 'top').scroll.to(:blah) }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe '#by' do
+        it 'offset' do
+          browser.scroll.to :top
+          pause
+          initial_top = current_top
+          browser.scroll.to :bottom
+          pause
+          scroll_by = top_centered_viewport
+
+          element = browser.div(id: 'bottom')
+          element.scroll.by(0, scroll_by)
+          pause
+          expect(current_top).to be_within(1).of(scroll_by + initial_top)
+        end
+      end
+
+      describe '#from',
+               except: [{browser: %i[firefox safari], reason: 'incorrect MoveTargetOutOfBoundsError'},
+                        {browser: :ie, reason: 'Not implemented'}] do
+        it 'scrolls from element by given amount' do
+          browser.goto(WatirSpec.url_for('scroll_nested_offscreen.html'))
+          iframe = browser.iframe
+
+          iframe.scroll.from.by(0, 200)
+
+          checkbox = iframe.checkbox(name: 'scroll_checkbox')
+          expect(in_viewport?(checkbox)).to be true
+        end
+
+        it 'scrolls from an element with an offset' do
+          browser.goto(WatirSpec.url_for('scroll_nested_offscreen.html'))
+
+          move_left = browser.execute_script('return arguments[0].getBoundingClientRect().width/2', browser.footer) -
+                      browser.execute_script('return arguments[0].getBoundingClientRect().right/2', browser.iframe.we)
+
+          browser.footer.scroll.from(-move_left.round, -50).by(0, 200)
+
+          checkbox = browser.iframe.checkbox(name: 'scroll_checkbox')
+          expect(in_viewport?(checkbox)).to be true
+        end
+      end
+    end
+
+    def in_viewport?(element)
+      in_viewport = <<~IN_VIEWPORT
+        for(var e=arguments[0],f=e.offsetTop,t=e.offsetLeft,o=e.offsetWidth,n=e.offsetHeight;
+        e.offsetParent;)f+=(e=e.offsetParent).offsetTop,t+=e.offsetLeft;
+        return f<window.pageYOffset+window.innerHeight&&t<window.pageXOffset+window.innerWidth&&f+n>
+        window.pageYOffset&&t+o>window.pageXOffset
+      IN_VIEWPORT
+
+      element.browser.execute_script(in_viewport, element.we)
+    end
+
+    def pause
+      sleep 0.2
+    end
+  end
+end

data/spec/watirspec/shadow_root_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'watirspec_helper'
+
+module Watir
+  describe ShadowRoot do
+    before do
+      browser.goto(WatirSpec.url_for('shadow_dom.html'))
+    end
+
+    context 'with errors' do
+      it 'returns false when element does not exist' do
+        missing_shadow_root = browser.div(id: 'does_not_exist').shadow_root
+        expect(missing_shadow_root).not_to exist
+      end
+
+      it 'raises ArgumentError when using :xpath to locate elements directly from the shadow root' do
+        shadow_root = browser.div(id: 'shadow_host').shadow_root
+        expect { shadow_root.element(xpath: './/span').exists? }.to raise_exception(ArgumentError)
+      end
+
+      it 'returns false when locating element in shadow root that does not exist',
+         except: {browser: %i[ie safari], reason: 'shadow endpoint not recognized'} do
+        missing_shadow_root = browser.div(id: 'non_host').shadow_root
+        expect(missing_shadow_root.element).not_to exist
+      end
+    end
+
+    context 'without errors', only: {browser: %i[firefox chrome edge]} do
+      describe '#exists?' do
+        it 'returns true when element has a shadow DOM' do
+          shadow_root = browser.div(id: 'shadow_host').shadow_root
+          expect(shadow_root).to exist
+        end
+
+        it 'returns false when element does not have a shadow DOM' do
+          missing_shadow_root = browser.div(id: 'non_host').shadow_root
+          expect(missing_shadow_root).not_to exist
+        end
+      end
+
+      describe 'locating' do
+        it 'locates a nested element' do
+          shadow_root = browser.div(id: 'shadow_host').shadow_root
+          expect(shadow_root.element.id).to eq('shadow_content')
+          expect(shadow_root.element(id: 'nested_shadow_host').id).to eq('nested_shadow_host')
+          expect(shadow_root.element(id: /nested_shadow_.+/).id).to eq('nested_shadow_host')
+          expect(shadow_root.element(css: 'div').id).to eq('nested_shadow_host')
+          expect(shadow_root.div.id).to eq('nested_shadow_host')
+        end
+
+        it 'locates a collection of nested elements' do
+          shadow_root = browser.div(id: 'shadow_host').shadow_root
+          expect(shadow_root.elements.count).to eq(8)
+          expect(shadow_root.elements(id: 'nested_shadow_host').map(&:id)).to eq(['nested_shadow_host'])
+          expect(shadow_root.elements(id: /nested_shadow_.+/).map(&:id)).to eq(['nested_shadow_host'])
+          expect(shadow_root.elements(css: 'div').map(&:id)).to eq(%w[nested_shadow_host chrome_workaround])
+          expect(shadow_root.divs.map(&:id)).to eq(%w[nested_shadow_host chrome_workaround])
+        end
+
+        it 'locates a nested element within a nested shadow DOM' do
+          shadow_root = browser.div(id: 'shadow_host').shadow_root
+          nested_shadow_root = shadow_root.element(id: 'nested_shadow_host').shadow_root
+          expect(nested_shadow_root.element.id).to eq('nested_shadow_content')
+        end
+
+        it 'locates a collection of nested elements within a nested shadow DOM' do
+          shadow_root = browser.div(id: 'shadow_host').shadow_root
+          nested_shadow_root = shadow_root.element(id: 'nested_shadow_host').shadow_root
+          expect(nested_shadow_root.elements.count).to eq(2)
+          expect(nested_shadow_root.elements.map(&:id)).to include('nested_shadow_content')
+        end
+
+        it 'allows using :xpath to locate elements with an element of a shadow root' do
+          shadow_root = browser.div(id: 'shadow_host').shadow_root
+          expect(shadow_root.span.element(xpath: './/span')).to exist
+        end
+
+        it 'click elements within the shadow dom' do
+          shadow_root = browser.div(id: 'shadow_host').shadow_root
+          shadow_root.link.click
+          expect(browser.url).to include('scroll.html')
+        end
+
+        it 'click! elements within the shadow dom' do
+          shadow_root = browser.div(id: 'shadow_host').shadow_root
+          shadow_root.link.click!
+
+          browser.wait_while(url: /shadow_dom|blank/)
+          expect(browser.url).to include('scroll.html')
+        end
+
+        it 'inputs form elements within the shadow dom' do
+          shadow_root = browser.div(id: 'shadow_host').shadow_root
+
+          shadow_root.text_field.set('abc')
+          expect(shadow_root.text_field.value).to eq('abc')
+
+          shadow_root.checkbox.set
+          expect(shadow_root.checkbox.set?).to be(true)
+
+          shadow_root.file_field.set(File.expand_path(__FILE__))
+          expect(shadow_root.file_field.value).to include('shadow_root_spec.rb')
+        end
+      end
+    end
+  end
+end

data/spec/watirspec/support/rspec_matchers.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+if defined?(RSpec)
+  LEVELS = %w[warning info deprecated].freeze
+
+  LEVELS.each do |level|
+    RSpec::Matchers.define "have_#{level}" do |entry|
+      match do |actual|
+        # Suppresses logging output to stdout while ensuring that it is still happening
+        default_output = Watir.logger.io
+        io = StringIO.new
+        Watir.logger.output = io
+
+        begin
+          actual.call
+        rescue StandardError => e
+          raise e, 'Can not evaluate output when statement raises an exception'
+        ensure
+          Watir.logger.output = default_output
+        end
+
+        @entries_found = (io.rewind && io.read).scan(/\[:([^\]]*)\]/).flatten.map(&:to_sym)
+        expect(Array(entry).sort).to eq(@entries_found.sort)
+      end
+
+      failure_message do
+        but_message = if @entries_found.nil? || @entries_found.empty?
+                        "no #{entry} entries were reported"
+                      else
+                        "instead these entries were found: [#{@entries_found.join(', ')}]"
+                      end
+        "expected :#{entry} to have been logged, but #{but_message}"
+      end
+
+      failure_message_when_negated do
+        but_message = "it was found among these entries: [#{@entries_found.join(', ')}]"
+        "expected :#{entry} not to have been logged, but #{but_message}"
+      end
+
+      def supports_block_expectations?
+        true
+      end
+    end
+  end
+
+  TIMING_EXCEPTIONS = {
+    unknown_object: Watir::Exception::UnknownObjectException,
+    no_matching_window: Watir::Exception::NoMatchingWindowFoundException,
+    unknown_frame: Watir::Exception::UnknownFrameException,
+    object_disabled: Watir::Exception::ObjectDisabledException,
+    object_read_only: Watir::Exception::ObjectReadOnlyException,
+    no_value_found: Watir::Exception::NoValueFoundException,
+    timeout: Watir::Wait::TimeoutError
+  }.freeze
+
+  TIMING_EXCEPTIONS.each do |matcher, exception|
+    RSpec::Matchers.define "raise_#{matcher}_exception" do |message|
+      match do |actual|
+        original_timeout = Watir.default_timeout
+        Watir.default_timeout = 0
+        begin
+          actual.call
+          false
+        rescue exception => e
+          return true if message.nil? || e.message.match(message)
+
+          raise exception, "expected '#{message}' to be included in: '#{e.message}'"
+        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
+
+    RSpec::Matchers.define "wait_and_raise_#{matcher}_exception" do |message = nil, timeout: 2|
+      match do |actual|
+        original_timeout = Watir.default_timeout
+        Watir.default_timeout = timeout
+        begin
+          start_time = Time.now
+          actual.call
+          false
+        rescue exception => e
+          finish_time = Time.now
+          unless message.nil? || e.message.match(message)
+            raise exception, "expected '#{message}' to be included in: '#{e.message}'"
+          end
+
+          @time_difference = finish_time - start_time
+          @time_difference > timeout
+        ensure
+          Watir.default_timeout = original_timeout
+        end
+      end
+
+      failure_message do
+        if @time_difference
+          "expected action to take more than provided timeout (#{timeout} seconds), " \
+            "instead it took #{@time_difference} seconds"
+        else
+          "expected #{exception} but nothing was raised"
+        end
+      end
+
+      def supports_block_expectations?
+        true
+      end
+    end
+  end
+
+  RSpec::Matchers.define :execute_when_satisfied do |min: 0, max: nil|
+    max ||= min + 1
+    match do |actual|
+      original_timeout = Watir.default_timeout
+      Watir.default_timeout = max
+      begin
+        start_time = Time.now
+        actual.call
+        @time_difference = Time.now - start_time
+        @time_difference > min && @time_difference < max
+      ensure
+        Watir.default_timeout = original_timeout
+      end
+    end
+
+    failure_message_when_negated do
+      "expected action to take less than #{min} seconds or more than #{max} seconds, " \
+        "instead it took #{@time_difference} seconds"
+    end
+
+    failure_message do
+      "expected action to take more than #{min} seconds and less than #{max} seconds, " \
+        "instead it took #{@time_difference} seconds"
+    end
+
+    def supports_block_expectations?
+      true
+    end
+  end
+
+  RSpec::Matchers.define :exist do |*args|
+    match do |actual|
+      actual.exist?(*args)
+    end
+
+    failure_message do |obj|
+      "expected #{obj.inspect} to exist"
+    end
+
+    failure_message_when_negated do |obj|
+      "expected #{obj.inspect} to not exist"
+    end
+  end
+end

data/spec/watirspec/user_editable_spec.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require 'watirspec_helper'
+
+module Watir
+  describe UserEditable do
+    before do
+      browser.goto(WatirSpec.url_for('forms_with_input_elements.html'))
+    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
+
+    describe '#clear' do
+      it 'removes all text from the text field' do
+        browser.text_field(name: 'new_user_occupation').clear
+        expect(browser.text_field(name: 'new_user_occupation').value).to be_empty
+        browser.textarea(id: 'delete_user_comment').clear
+        expect(browser.textarea(id: 'delete_user_comment').value).to be_empty
+      end
+
+      it 'removes all text from the content editable element' do
+        browser.div(id: 'contenteditable').clear
+        expect(browser.div(id: 'contenteditable').text).to eq ''
+      end
+
+      it "raises UnknownObjectException if the text field doesn't exist" do
+        expect { browser.text_field(id: 'no_such_id').clear }.to raise_unknown_object_exception
+      end
+
+      it 'raises ObjectReadOnlyException if the object is read only' do
+        expect { browser.text_field(id: 'new_user_code').clear }.to raise_object_read_only_exception
+      end
+    end
+
+    describe '#value=' do
+      it 'sets the value of the element' do
+        browser.text_field(id: 'new_user_email').value = 'Hello Cruel World'
+        expect(browser.text_field(id: 'new_user_email').value).to eq 'Hello Cruel World'
+      end
+
+      it 'is able to set multi-byte characters' do
+        browser.text_field(name: 'new_user_occupation').value = 'ijij'
+        expect(browser.text_field(name: 'new_user_occupation').value).to eq 'ijij'
+      end
+
+      it 'sets the value of a textarea element' do
+        browser.textarea(id: 'delete_user_comment').value = 'Hello Cruel World'
+        expect(browser.textarea(id: 'delete_user_comment').value).to eq 'Hello Cruel World'
+      end
+
+      it "raises UnknownObjectException if the text field doesn't exist" do
+        expect { browser.text_field(name: 'no_such_name').value = 'yo' }.to raise_unknown_object_exception
+      end
+    end
+
+    describe '#set' do
+      it 'sets the value of the element' do
+        browser.text_field(id: 'new_user_email').set('Bye Cruel World')
+        expect(browser.text_field(id: 'new_user_email').value).to eq 'Bye Cruel World'
+      end
+
+      it 'sets the value of a textarea element' do
+        browser.textarea(id: 'delete_user_comment').set('Hello Cruel World')
+        expect(browser.textarea(id: 'delete_user_comment').value).to eq 'Hello Cruel World'
+      end
+
+      it 'sets the value of a content editable element' do
+        browser.div(id: 'contenteditable').set('Bar')
+        expect(browser.div(id: 'contenteditable').text).to eq 'Bar'
+      end
+
+      it 'fires events' do
+        browser.text_field(id: 'new_user_username').set('Hello World')
+        expect(browser.span(id: 'current_length').text).to eq '11'
+      end
+
+      it 'sets the value of a password field' do
+        browser.text_field(name: 'new_user_password').set('secret')
+        expect(browser.text_field(name: 'new_user_password').value).to eq 'secret'
+      end
+
+      it 'sets the value when accessed through the enclosing Form' do
+        browser.form(id: 'new_user').text_field(name: 'new_user_password').set('secret')
+        expect(browser.form(id: 'new_user').text_field(name: 'new_user_password').value).to eq 'secret'
+      end
+
+      it 'is able to set multi-byte characters' do
+        browser.text_field(name: 'new_user_occupation').set('ijij')
+        expect(browser.text_field(name: 'new_user_occupation').value).to eq 'ijij'
+      end
+
+      it 'sets the value to a concatenation of multiple arguments' do
+        browser.text_field(id: 'new_user_email').set('Bye', 'Cruel', 'World')
+        expect(browser.text_field(id: 'new_user_email').value).to eq 'ByeCruelWorld'
+      end
+
+      it 'sets the value to blank when no arguments are provided' do
+        browser.text_field(id: 'new_user_email').set
+        expect(browser.text_field(id: 'new_user_email').value).to eq ''
+      end
+
+      it "raises UnknownObjectException if the text field doesn't exist" do
+        expect { browser.text_field(id: 'no_such_id').set('secret') }.to raise_unknown_object_exception
+      end
+
+      it 'raises ObjectReadOnlyException if the object is read only' do
+        expect { browser.text_field(id: 'new_user_code').set('Foo') }.to raise_object_read_only_exception
+      end
+    end
+
+    describe '#set!' do
+      it 'sets the value of the element' do
+        browser.text_field(id: 'new_user_email').set!('Bye Cruel World')
+        expect(browser.text_field(id: 'new_user_email').value).to eq 'Bye Cruel World'
+      end
+
+      it 'sets the value of a textarea element' do
+        browser.textarea(id: 'delete_user_comment').set!('Hello Cruel World')
+        expect(browser.textarea(id: 'delete_user_comment').value).to eq 'Hello Cruel World'
+      end
+
+      it 'sets the value of a content editable element' do
+        browser.div(id: 'contenteditable').set!('foo')
+        expect(browser.div(id: 'contenteditable').text).to eq 'foo'
+      end
+
+      it 'fires events' do
+        browser.text_field(id: 'new_user_username').set!('Hello World')
+        expect(browser.span(id: 'current_length').text).to eq '11'
+      end
+
+      it 'sets the value of a password field' do
+        browser.text_field(name: 'new_user_password').set!('secret')
+        expect(browser.text_field(name: 'new_user_password').value).to eq 'secret'
+      end
+
+      it 'sets the value when accessed through the enclosing Form' do
+        browser.form(id: 'new_user').text_field(name: 'new_user_password').set!('secret')
+        expect(browser.form(id: 'new_user').text_field(name: 'new_user_password').value).to eq 'secret'
+      end
+
+      it 'is able to set multi-byte characters' do
+        browser.text_field(name: 'new_user_occupation').set!('ijij')
+        expect(browser.text_field(name: 'new_user_occupation').value).to eq 'ijij'
+      end
+
+      it 'sets the value to a concatenation of multiple arguments' do
+        browser.text_field(id: 'new_user_email').set!('Bye', 'Cruel', 'World')
+        expect(browser.text_field(id: 'new_user_email').value).to eq 'ByeCruelWorld'
+      end
+
+      it 'sets the value to blank when no arguments are provided' do
+        browser.text_field(id: 'new_user_email').set!
+        expect(browser.text_field(id: 'new_user_email').value).to eq ''
+      end
+
+      it 'raises ArgumentError for special keys' do
+        expect { browser.text_field(id: 'new_user_email').set!('a', :tab) }.to raise_error(ArgumentError)
+      end
+
+      it "raises UnknownObjectException if the text field doesn't exist" do
+        expect { browser.text_field(id: 'no_such_id').set!('secret') }.to raise_unknown_object_exception
+      end
+
+      it "raises Exception if the value of text field doesn't match" do
+        element = browser.text_field(id: 'new_user_password')
+        allow(element).to receive(:value).and_return('wrong')
+        msg = "#set! value: 'wrong' does not match expected input: 'secret'"
+        expect { element.set!('secret') }.to raise_exception(Watir::Exception::Error, msg)
+      end
+
+      it "raises Exception if the text of content editable element doesn't match" do
+        element = browser.div(id: 'contenteditable')
+        allow(element).to receive(:text).and_return('wrong')
+        msg = "#set! text: 'wrong' does not match expected input: 'secret'"
+        expect { element.set!('secret') }.to raise_exception(Watir::Exception::Error, msg)
+      end
+    end
+  end
+end