watir 7.2.0 → 7.2.1

data/spec/watirspec/screenshot_spec.rb

@@ -3,29 +3,31 @@
 require 'base64'
 require 'watirspec_helper'
 
-describe 'Watir::Screenshot' do
-  let(:png_header) { (+"\211PNG").force_encoding('ASCII-8BIT') }
+module Watir
+  describe 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
+    describe '#png' do
+      it 'gets png representation of screenshot' do
+        expect(browser.screenshot.png[0..3]).to eq png_header
+      end
     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
+    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
-  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.binread(path)[0..3]).to eq png_header
+    describe '#save' do
+      it 'saves screenshot to given file' do
+        path = "#{Dir.tmpdir}/test#{::Time.now.to_i}.png"
+        expect(File).not_to exist(path)
+        browser.screenshot.save(path)
+        expect(File).to exist(path)
+        expect(File.binread(path)[0..3]).to eq png_header
+      end
     end
   end
 end

data/spec/watirspec/scroll_spec.rb

@@ -2,203 +2,207 @@
 
 require 'watirspec_helper'
 
-describe Watir::Scrolling do
-  before(:each) do
-    browser.goto(WatirSpec.url_for('scroll.html'))
-    pause
-  end
+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 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
+    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
+    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;')
+        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
+          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 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 '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)
+        it 'raises error when scroll point is not valid' do
+          expect { browser.scroll.to(:blah) }.to raise_error(ArgumentError)
+        end
       end
-    end
 
-    describe '#by' do
-      before do
-        browser.scroll.to :top
-        pause
-      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 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)
+        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
-    end
 
-    describe '#from' do
-      it 'scrolls by given amount with offset' do
-        browser.goto(WatirSpec.url_for('scroll_nested.html'))
+      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)
+          browser.scroll.from(10, 10).by(0, 225)
 
-        expect(in_viewport?(browser.iframe.checkbox(name: 'scroll_checkbox'))).to eq true
+          expect(in_viewport?(browser.iframe.checkbox(name: 'scroll_checkbox'))).to be true
+        end
       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'} do
-        browser.goto(WatirSpec.url_for('scroll_nested_offscreen.html'))
-        iframe = browser.iframe
+    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 eq false
+          expect(in_viewport?(iframe)).to be false
 
-        iframe.scroll.to(:viewport)
+          iframe.scroll.to(:viewport)
 
-        expect(in_viewport?(iframe)).to eq true
-      end
+          expect(in_viewport?(iframe)).to be true
+        end
 
-      it 'scrolls to element (top) by default' do
-        element = browser.div(id: 'center')
-        element.scroll.to
+        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
+          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
+        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)
+          element_rect = browser.execute_script('return arguments[0].getBoundingClientRect()', element)
 
-        expect(element_rect['top']).to eq(element_rect['bottom'] - element_rect['height'])
-      end
+          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
+        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')
+          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
+          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)
+        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)
+            element_rect = browser.execute_script('return arguments[0].getBoundingClientRect()', element)
 
-          expect(element_rect['top']).to eq(element_rect['bottom'] - element_rect['height'])
+            expect(element_rect['top']).to eq(element_rect['bottom'] - element_rect['height'])
+          end
         end
-      end
 
-      it 'raises error when scroll param is not valid' do
-        expect { browser.div(id: 'top').scroll.to(:blah) }.to raise_error(ArgumentError)
+        it 'raises error when scroll param is not valid' do
+          expect { browser.div(id: 'top').scroll.to(:blah) }.to raise_error(ArgumentError)
+        end
       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)
+      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
-    end
 
-    describe '#from',
-             except: {browser: %i[firefox safari], reason: 'incorrect MoveTargetOutOfBoundsError'} do
-      it 'scrolls from element by given amount' do
-        browser.goto(WatirSpec.url_for('scroll_nested_offscreen.html'))
-        iframe = browser.iframe
+      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)
+          iframe.scroll.from.by(0, 200)
 
-        checkbox = iframe.checkbox(name: 'scroll_checkbox')
-        expect(in_viewport?(checkbox)).to eq true
-      end
+          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'))
+        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)
+          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)
+          browser.footer.scroll.from(-move_left.round, -50).by(0, 200)
 
-        checkbox = browser.iframe.checkbox(name: 'scroll_checkbox')
-        expect(in_viewport?(checkbox)).to eq true
+          checkbox = browser.iframe.checkbox(name: 'scroll_checkbox')
+          expect(in_viewport?(checkbox)).to be true
+        end
       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
+    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
+      element.browser.execute_script(in_viewport, element.we)
+    end
 
-  def pause
-    sleep 0.2
+    def pause
+      sleep 0.2
+    end
   end
 end

data/spec/watirspec/shadow_root_spec.rb

@@ -2,101 +2,104 @@
 
 require 'watirspec_helper'
 
-describe 'ShadowRoot' do
-  before :each 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: :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
+module Watir
+  describe ShadowRoot do
+    before do
+      browser.goto(WatirSpec.url_for('shadow_dom.html'))
     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
+    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
-    end
-
-    describe 'locating', except: {browser: :firefox, reason: 'location not supported yet'} 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
+      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.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])
+        expect { shadow_root.element(xpath: './/span').exists? }.to raise_exception(ArgumentError)
       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')
+      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
 
-      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')
+    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
 
-      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 eq(true)
-
-        shadow_root.file_field.set(File.expand_path(__FILE__))
-        expect(shadow_root.file_field.value).to include('shadow_root_spec.rb')
+      describe 'locating', except: {browser: :firefox, reason: 'location not supported yet'} 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!
+          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