watir 7.0.0.beta3 → 7.1.0

data/spec/unit/capabilities_spec.rb

@@ -39,11 +39,12 @@ describe Watir::Capabilities do
   # :listener
   # :service      (Built from Hash)
   # :http_client  (Generated or Built from Hash)
+  # :proxy        (Built from Hash and added to :options)
   # :options      (Generated or Built from Hash)
   # :capabilities (incompatible with options)
 
   supported_browsers.each do |browser_symbol|
-    it 'just browser has client & capabilities not service' do
+    it 'just browser has client & options not service' do
       capabilities = Watir::Capabilities.new(browser_symbol)
 
       args = capabilities.to_args
@@ -74,7 +75,7 @@ describe Watir::Capabilities do
       expect(args.last).not_to include(:service)
     end
 
-    context 'service' do
+    describe 'service' do
       it 'uses provided service' do
         halt_service(browser_symbol)
 
@@ -106,7 +107,7 @@ describe Watir::Capabilities do
       end
     end
 
-    context 'http_client' do
+    describe 'http_client' do
       it 'uses default HTTP Client' do
         capabilities = Watir::Capabilities.new(browser_symbol)
         args = capabilities.to_args
@@ -153,7 +154,7 @@ describe Watir::Capabilities do
       }.to raise_exception(ArgumentError, ':capabilities and :options are not both allowed')
     end
 
-    context 'timeout options' do
+    describe 'timeout options' do
       it 'accepts page load and script timeouts in seconds' do
         options = {page_load_timeout: 11,
                    script_timeout: 12}
@@ -203,6 +204,63 @@ describe Watir::Capabilities do
       actual_options = args.last[:capabilities].first
       expect(actual_options.unhandled_prompt_behavior).to eq :accept_and_notify
     end
+
+    describe 'proxy' do
+      it 'adds Selenium Proxy to empty Options' do
+        proxy = Selenium::WebDriver::Proxy.new(http: '127.0.0.1:8080', ssl: '127.0.0.1:443')
+        capabilities = Watir::Capabilities.new(browser_symbol, proxy: proxy)
+        args = capabilities.to_args
+        proxy = args.last[:capabilities].first.proxy
+
+        expect(proxy).to be_a Selenium::WebDriver::Proxy
+        expect(proxy.type).to eq(:manual)
+        expect(proxy.http).to eq('127.0.0.1:8080')
+        expect(proxy.ssl).to eq('127.0.0.1:443')
+      end
+
+      it 'builds a Proxy from Hash for Options' do
+        proxy = {http: '127.0.0.1:8080', ssl: '127.0.0.1:443'}
+        capabilities = Watir::Capabilities.new(browser_symbol, proxy: proxy)
+        args = capabilities.to_args
+        proxy = args.last[:capabilities].first.proxy
+
+        expect(proxy).to be_a Selenium::WebDriver::Proxy
+        expect(proxy.type).to eq(:manual)
+        expect(proxy.http).to eq('127.0.0.1:8080')
+        expect(proxy.ssl).to eq('127.0.0.1:443')
+      end
+
+      it 'builds a Proxy from Hash and adds to Options' do
+        proxy = {http: '127.0.0.1:8080', ssl: '127.0.0.1:443'}
+        options = {unhandled_prompt_behavior: :accept,
+                   page_load_strategy: :eager}
+
+        capabilities = Watir::Capabilities.new(browser_symbol, options: options, proxy: proxy)
+        args = capabilities.to_args
+        actual_options = args.last[:capabilities].first
+
+        expect(actual_options.proxy).to be_a Selenium::WebDriver::Proxy
+        expect(actual_options.proxy.type).to eq(:manual)
+        expect(actual_options.proxy.http).to eq('127.0.0.1:8080')
+        expect(actual_options.proxy.ssl).to eq('127.0.0.1:443')
+        expect(actual_options.unhandled_prompt_behavior).to eq :accept
+        expect(actual_options.page_load_strategy).to eq :eager
+      end
+    end
+
+    it 'errors on bad proxy key' do
+      proxy = {bad_key: 'foo'}
+      capabilities = Watir::Capabilities.new(browser_symbol, proxy: proxy)
+
+      expect { capabilities.to_args }.to raise_error(ArgumentError, /unknown option/)
+    end
+
+    it 'errors on bad proxy object' do
+      capabilities = Watir::Capabilities.new(browser_symbol, proxy: 7)
+      expect {
+        capabilities.to_args
+      }.to raise_exception(TypeError, '7 needs to be Selenium Proxy or Hash instance')
+    end
   end
 
   # Options:
@@ -210,6 +268,7 @@ describe Watir::Capabilities do
   # :service      (Errors)
   # :listener
   # :http_client  (Generated or Built from Hash)
+  # :proxy        (Built from Hash and added to :options)
   # :options      (Generated or Built from Hash)
   # :capabilities (incompatible with options)
 
@@ -266,6 +325,34 @@ describe Watir::Capabilities do
       expect(actual_options.browser_name).to eq 'chrome'
     end
 
+    it 'accepts proxy object' do
+      proxy = Selenium::WebDriver::Proxy.new(http: '127.0.0.1:8080', ssl: '127.0.0.1:443')
+      capabilities = Watir::Capabilities.new(:chrome,
+                                             url: 'https://example.com/wd/hub',
+                                             proxy: proxy)
+      args = capabilities.to_args
+      expect(args.first).to eq :remote
+      proxy = args.last[:capabilities].first.proxy
+      expect(proxy).to be_a Selenium::WebDriver::Proxy
+      expect(proxy.type).to eq(:manual)
+      expect(proxy.http).to eq('127.0.0.1:8080')
+      expect(proxy.ssl).to eq('127.0.0.1:443')
+    end
+
+    it 'accepts proxy Hash' do
+      proxy = {http: '127.0.0.1:8080', ssl: '127.0.0.1:443'}
+      capabilities = Watir::Capabilities.new(:chrome,
+                                             url: 'https://example.com/wd/hub',
+                                             proxy: proxy)
+      args = capabilities.to_args
+      expect(args.first).to eq :remote
+      proxy = args.last[:capabilities].first.proxy
+      expect(proxy).to be_a Selenium::WebDriver::Proxy
+      expect(proxy.type).to eq(:manual)
+      expect(proxy.http).to eq('127.0.0.1:8080')
+      expect(proxy.ssl).to eq('127.0.0.1:443')
+    end
+
     it 'accepts options object' do
       capabilities = Watir::Capabilities.new(:chrome,
                                              url: 'https://example.com/wd/hub',
@@ -316,11 +403,13 @@ describe Watir::Capabilities do
       expect(actual_capabilities.browser_name).to eq 'chrome'
     end
 
-    it 'accepts http client & options objects' do
+    it 'accepts http client & proxy & options objects' do
       client = Watir::HttpClient.new
+      proxy = {http: '127.0.0.1:8080', ssl: '127.0.0.1:443'}
       options = Selenium::WebDriver::Chrome::Options.new(prefs: {foo: 'bar'})
       caps = Watir::Capabilities.new(:chrome,
                                      url: 'https://example.com/wd/hub',
+                                     proxy: proxy,
                                      options: options,
                                      http_client: client)
 
@@ -330,6 +419,11 @@ describe Watir::Capabilities do
       actual_options = args.last[:capabilities].first
       expect(actual_options).to be_a(Selenium::WebDriver::Chrome::Options)
       expect(actual_options.prefs).to eq(foo: 'bar')
+      proxy = args.last[:capabilities].first.proxy
+      expect(proxy).to be_a Selenium::WebDriver::Proxy
+      expect(proxy.type).to eq(:manual)
+      expect(proxy.http).to eq('127.0.0.1:8080')
+      expect(proxy.ssl).to eq('127.0.0.1:443')
     end
 
     it 'raises exception when both options & capabilities defined' do

data/spec/watirspec/after_hooks_spec.rb

@@ -98,7 +98,6 @@ describe 'Browser::AfterHooks' do
       @page_after_hook = proc { @yield = browser.title == 'Non-control elements' }
       browser.after_hooks.add @page_after_hook
       div = browser.div(id: 'html_test')
-      div.scroll.to
       div.double_click
       expect(@yield).to be true
     end
@@ -108,7 +107,6 @@ describe 'Browser::AfterHooks' do
       @page_after_hook = proc { @yield = browser.title == 'Right Click Test' }
       browser.after_hooks.add @page_after_hook
       div = browser.div(id: 'click')
-      div.scroll.to
       div.right_click
       expect(@yield).to be true
     end

data/spec/watirspec/drag_and_drop_spec.rb

@@ -13,10 +13,22 @@ describe 'Element' do
       expect(droppable.text).to include 'Dropped!'
     end
 
+    it 'can drag and drop an element onto another with specified scroll position' do
+      expect(droppable.text).to include 'Drop here'
+      draggable.drag_and_drop_on droppable, scroll_to: :center
+      expect(droppable.text).to include 'Dropped!'
+    end
+
     it 'can drag an element by the given offset' do
       expect(droppable.text).to include 'Drop here'
       draggable.drag_and_drop_by 200, 50
       expect(droppable.text).to include 'Dropped!'
     end
+
+    it 'can drag an element by the given offset with specified scroll position' do
+      expect(droppable.text).to include 'Drop here'
+      draggable.drag_and_drop_by 200, 50, scroll_to: :center
+      expect(droppable.text).to include 'Dropped!'
+    end
   end
 end

data/spec/watirspec/elements/date_time_field_spec.rb

@@ -20,8 +20,7 @@ describe 'DateTimeField' do
     end
 
     it 'returns true if the datetime-local element exists',
-       except: [{browser: :firefox, reason: 'https://github.com/mozilla/geckodriver/issues/1469'},
-                {browser: :ie, reason: 'Date type not recognized'}] do
+       except: {browser: :ie, reason: 'Date type not recognized'} do
       expect(browser.date_time_field(xpath: "//input[@id='html5_datetime-local']")).to exist
     end
 
@@ -30,8 +29,7 @@ describe 'DateTimeField' do
     end
 
     it 'respects date-time fields types',
-       except: [{browser: :firefox, reason: 'https://github.com/mozilla/geckodriver/issues/1469'},
-                {browser: :ie, reason: 'Date type not recognized'}] do
+       except: {browser: :ie, reason: 'Date type not recognized'} do
       expect(browser.date_time_field.type).to eq('datetime-local')
     end
 
@@ -80,8 +78,7 @@ describe 'DateTimeField' do
 
   describe '#type' do
     it 'returns the type attribute if the date-time field exists',
-       except: [{browser: :firefox, reason: 'https://github.com/mozilla/geckodriver/issues/1469'},
-                {browser: :ie, reason: 'Date type not recognized'}] do
+       except: {browser: :ie, reason: 'Date type not recognized'} do
       expect(browser.date_time_field(id: 'html5_datetime-local').type).to eq 'datetime-local'
     end
 

data/spec/watirspec/elements/div_spec.rb

@@ -170,10 +170,15 @@ describe 'Div' do
            except: {browser: :safari, reason: 'command correctly received, but action not taken'} do
     it 'fires the ondblclick event' do
       div = browser.div(id: 'html_test')
-      div.scroll.to
       div.double_click
       expect(messages).to include('double clicked')
     end
+
+    it 'fires the ondblclick event with specified scroll position' do
+      div = browser.div(id: 'html_test')
+      div.double_click(scroll_to: :center)
+      expect(messages).to include('double clicked')
+    end
   end
 
   describe '#double_click!' do
@@ -196,6 +201,12 @@ describe 'Div' do
       expect(event_log.first).to eq('control=true alt=true')
     end
 
+    it 'accepts modifiers with scroll position', except: {browser: :ie} do
+      browser.goto(WatirSpec.url_for('right_click.html'))
+      browser.div(id: 'click-logger').right_click(:control, :alt, scroll_to: :center)
+      expect(event_log.first).to eq('control=true alt=true')
+    end
+
     it 'scrolls' do
       browser.del(class: 'footer').double_click
       puts 'yes?'

data/spec/watirspec/elements/element_spec.rb

@@ -623,15 +623,65 @@ describe 'Element' do
   end
 
   describe '#hover' do
-    it 'should hover over the element', except: {browser: :ie} do
-      browser.goto WatirSpec.url_for('hover.html')
-      link = browser.a
+    def element_color(element)
+      case element.style('color')
+      when 'rgba(0, 0, 255, 1)'
+        :blue
+      when 'rgba(255, 165, 0, 1)', 'rgb(255, 165, 0)'
+        :orange
+      else
+        raise rgba
+      end
+    end
+
+    it 'allows scrolling to top', except: {browser: :ie,
+                                           reason: 'needs require_window_focus'} do
+      browser.goto(WatirSpec.url_for('scroll.html'))
+      element = browser.div(id: 'center')
+
+      element.hover(scroll_to: :top)
+      expect(element_color(element)).to eq :orange
+
+      element_top = browser.execute_script('return arguments[0].getBoundingClientRect().top', element)
+      expect(element_top).to be_within(1).of(0)
+    end
+
+    it 'scrolls to center by default', except: {browser: :ie,
+                                                reason: 'needs require_window_focus'} do
+      browser.goto(WatirSpec.url_for('scroll.html'))
+      element = browser.div(id: 'center')
+
+      element.hover
+      expect(element_color(element)).to eq :orange
+
+      element_rect = browser.execute_script('return arguments[0].getBoundingClientRect()', element)
+
+      expect(element_rect['top']).to eq(element_rect['bottom'] - element_rect['height'])
+    end
+
+    it 'allows scrolling to bottom', except: {browser: :ie,
+                                              reason: 'needs require_window_focus'} do
+      browser.goto(WatirSpec.url_for('scroll.html'))
+      element = browser.div(id: 'center')
+
+      element.hover(scroll_to: :bottom)
+      expect(element_color(element)).to eq :orange
+
+      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 'allows not scrolling', except: {browser: %i[chrome edge],
+                                        reason: 'https://bugs.chromium.org/p/chromedriver/issues/detail?id=3955'} do
+      browser.goto(WatirSpec.url_for('scroll.html'))
+      element = browser.div(id: 'center')
+
+      browser.execute_script('return window.pageYOffset;')
+      browser.execute_script('return window.innerHeight;')
 
-      expect(link.style('font-size')).to eq '10px'
-      link.scroll.to
-      link.hover
-      link.wait_until { |l| l.style('font-size') == '20px' }
-      expect(link.style('font-size')).to eq '20px'
+      expect { element.hover(scroll_to: nil) }.to raise_exception Selenium::WebDriver::Error::MoveTargetOutOfBoundsError
     end
   end
 
@@ -914,40 +964,63 @@ describe 'Element' do
 
     it 'returns false if element center is not covered' do
       btn = browser.button(id: 'not_obscured')
-      expect(btn).not_to be_obscured
+      btn.scroll.to :center
       expect { btn.click }.not_to raise_exception
+      expect(btn).not_to be_obscured
     end
 
     it 'returns false if element center is covered by its descendant' do
       btn = browser.button(id: 'has_descendant')
-      expect(btn).not_to be_obscured
+      btn.scroll.to :center
       expect { btn.click }.not_to raise_exception
+      expect(btn).not_to be_obscured
     end
 
     it 'returns true if element center is covered by a non-descendant',
        except: {browser: :safari, reason: 'not getting element click intercepted'} do
       btn = browser.button(id: 'obscured')
-      expect(btn).to be_obscured
-
+      btn.scroll.to :center
       expect { btn.click }.to raise_exception(Selenium::WebDriver::Error::ElementClickInterceptedError)
+      expect(btn).to be_obscured
     end
 
     it 'returns false if element center is surrounded by non-descendants' do
       btn = browser.button(id: 'surrounded')
-      expect(btn).not_to be_obscured
+      btn.scroll.to :center
       expect { btn.click }.not_to raise_exception
+      expect(btn).not_to be_obscured
     end
 
-    it 'scrolls interactive element into view before checking if obscured' do
-      btn = browser.button(id: 'requires_scrolling')
-      expect(btn).not_to be_obscured
-      expect { btn.click }.not_to raise_exception
+    it 'correctly scrolls element below viewport' do
+      browser.goto WatirSpec.url_for('sticky_elements.html')
+
+      element = browser.div(id: 'center')
+
+      browser.scroll.to :top
+      expect { element.click }.not_to raise_exception
+
+      browser.scroll.to :top
+      expect(element).not_to be_obscured
+    end
+
+    it 'correctly scrolls element above viewport',
+       except: {browser: %i[chrome edge],
+                reason: 'https://bugs.chromium.org/p/chromedriver/issues/detail?id=3954'} do
+      browser.goto WatirSpec.url_for('sticky_elements.html')
+      element = browser.div(id: 'center')
+
+      browser.scroll.to :bottom
+      expect { element.click }.not_to raise_exception
+
+      browser.scroll.to :bottom
+      expect(element).not_to be_obscured
     end
 
     it 'scrolls non-interactive element into view before checking if obscured' do
       div = browser.div(id: 'requires_scrolling_container')
-      expect(div).not_to be_obscured
       expect { div.click }.not_to raise_exception
+      browser.scroll.to :top
+      expect(div).not_to be_obscured
     end
 
     it 'returns true if element cannot be scrolled into view' do

data/spec/watirspec/html/scroll.html

@@ -1,32 +1,15 @@
 <html>
   <head>
-    <script>
-      function isElementInViewport(el) {
-        var top = el.offsetTop;
-        var left = el.offsetLeft;
-        var width = el.offsetWidth;
-        var height = el.offsetHeight;
-
-        while (el.offsetParent) {
-          el = el.offsetParent;
-          top += el.offsetTop;
-          left += el.offsetLeft;
-        }
-
-        return (
-          top < (window.pageYOffset + window.innerHeight) &&
-          left < (window.pageXOffset + window.innerWidth) &&
-          (top + height) > window.pageYOffset &&
-          (left + width) > window.pageXOffset
-        );
-      }
-    </script>
+    <style media="screen">
+      div { color: blue; }
+      div:hover { color: orange; }
+    </style>
   </head>
   <body>
-    <div style="height: 180%; position: relative;">
-      <button style="position: absolute;">Top</button>
-      <button style="position: absolute; top: 50%;">Center</button>
-      <button style="position: absolute; bottom: 0;">Bottom</button>
+    <div style="height: 300%; position: relative;">
+      <div id="top" style="position: absolute; top: 0;">top</div>
+      <div id="center" style="position: absolute; top: 50%;">Center</div>
+      <div id="bottom" style="position: absolute; top: 100%;">bottom</div>
     </div>
   </body>
 </html>

data/spec/watirspec/html/sticky_elements.html

@@ -0,0 +1,10 @@
+<html>
+  <body>
+    <div style="height: 300%; position: relative;">
+      <header style="position: sticky; z-index: 10; top: 0;"><h1>Sticky Header</h1></header>
+      <div id="top" style="position: absolute; top: 0;">top</div>
+      <div id="center" style="position: absolute; top: 50%;">Center</div>
+      <div id="bottom" style="position: absolute; top: 100%;">bottom</div>
+    </div>
+  </body>
+</html>

data/spec/watirspec/scroll_spec.rb

@@ -5,101 +5,131 @@ describe Watir::Scrolling do
     browser.goto(WatirSpec.url_for('scroll.html'))
   end
 
-  def visible?(element)
-    browser.execute_script('return isElementInViewport(arguments[0]);', element)
+  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(visible?(browser.button(text: 'Top'))).to eq(true)
-        expect(visible?(browser.button(text: 'Center'))).to eq(true)
-        expect(visible?(browser.button(text: 'Bottom'))).to eq(false)
+        expect(browser.div(id: 'top')).to be_in_viewport
       end
 
       it 'scrolls to the center of the page' do
         browser.scroll.to :center
-        expect(visible?(browser.button(text: 'Top'))).to eq(false)
-        expect(visible?(browser.button(text: 'Center'))).to eq(true)
-        expect(visible?(browser.button(text: 'Bottom'))).to eq(false)
+        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(visible?(browser.button(text: 'Top'))).to eq(false)
-        expect(visible?(browser.button(text: 'Center'))).to eq(true)
-        expect(visible?(browser.button(text: 'Bottom'))).to eq(true)
+        expect(browser.div(id: 'bottom')).to be_in_viewport
       end
 
       it 'scrolls to coordinates' do
-        button = browser.button(text: 'Bottom')
-        browser.scroll.to [button.wd.location.x, button.wd.location.y]
-        expect(visible?(button)).to eq(true)
+        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 vaild' do
+      it 'raises error when scroll point is not valid' do
         expect { browser.scroll.to(:blah) }.to raise_error(ArgumentError)
       end
     end
 
     describe '#by' do
-      it 'offset' do
+      before do
+        sleep(0.1)
+        browser.scroll.to :top
+      end
+
+      it 'offset from top' do
+        initial_top = current_top
+        scroll_by = top_centered_viewport
+        browser.scroll.by(0, -scroll_by)
+
+        expect(current_top).to be_within(1).of(scroll_by + initial_top)
+      end
+
+      it 'offset from bottom' do
+        browser.scroll.to :top
+        initial_top = current_top
         browser.scroll.to :bottom
-        browser.scroll.by(-10_000, -10_000)
+        scroll_by = top_centered_viewport
+        browser.scroll.by(0, scroll_by)
 
-        expect(visible?(browser.button(text: 'Top'))).to eq(true)
-        expect(visible?(browser.button(text: 'Center'))).to eq(true)
-        expect(visible?(browser.button(text: 'Bottom'))).to eq(false)
+        expect(current_top).to be_within(1).of(scroll_by + initial_top)
       end
     end
   end
 
   context 'when scrolling Element' do
     describe '#to' do
-      it 'scrolls to element (top)' do
-        browser.button(text: 'Center').scroll.to
-        expect(visible?(browser.button(text: 'Top'))).to eq(false)
-        expect(visible?(browser.button(text: 'Center'))).to eq(true)
-        expect(visible?(browser.button(text: 'Bottom'))).to eq(true)
+      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
-        browser.button(text: 'Center').scroll.to :center
-        expect(visible?(browser.button(text: 'Top'))).to eq(false)
-        expect(visible?(browser.button(text: 'Center'))).to eq(true)
-        expect(visible?(browser.button(text: 'Bottom'))).to eq(false)
+        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
-        browser.button(text: 'Center').scroll.to :bottom
-        expect(visible?(browser.button(text: 'Top'))).to eq(true)
-        expect(visible?(browser.button(text: 'Center'))).to eq(true)
-        expect(visible?(browser.button(text: 'Bottom'))).to eq(false)
+        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
-          browser.button(text: 'Center').scroll.to(:center)
-          expect(visible?(browser.button(text: 'Top'))).to eq(false)
+          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 vaild' do
-        expect { browser.button(text: '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
 
     describe '#by' do
       it 'offset' do
+        sleep 0.1
+        browser.scroll.to :top
+        initial_top = current_top
         browser.scroll.to :bottom
-        button = browser.button(text: 'Bottom')
-        button.scroll.by(-10_000, -10_000) # simulate scrolling to top
+        scroll_by = top_centered_viewport
+
+        element = browser.div(id: 'bottom')
+        element.scroll.by(0, scroll_by)
 
-        expect(visible?(browser.button(text: 'Top'))).to eq(true)
-        expect(visible?(browser.button(text: 'Center'))).to eq(true)
-        expect(visible?(browser.button(text: 'Bottom'))).to eq(false)
+        expect(current_top).to be_within(1).of(scroll_by + initial_top)
       end
     end
   end