watir 6.15.1 → 6.16.0

data/lib/watir/locators/element/selector_builder/xpath.rb

@@ -17,6 +17,7 @@ module Watir
 
             index = @selector.delete(:index)
             @adjacent = @selector.delete(:adjacent)
+            @scope = @selector.delete(:scope)
 
             xpath = start_string
             xpath << adjacent_string
@@ -75,7 +76,8 @@ module Watir
           end
 
           def start_string
-            @adjacent ? './' : './/*'
+            start = @adjacent ? './' : './/*'
+            @scope ? "(#{@scope[:xpath]})[1]#{start.tr('.', '')}" : start
           end
 
           def adjacent_string
@@ -104,8 +106,6 @@ module Watir
             class_name = @selector.delete(:class)
             return '' if class_name.nil?
 
-            deprecate_class_array(class_name) if class_name.is_a?(String) && class_name.strip.include?(' ')
-
             @built[:class] = []
 
             predicates = [class_name].flatten.map { |value| process_attribute(:class, value) }.compact
@@ -181,13 +181,6 @@ module Watir
             end
           end
 
-          def deprecate_class_array(class_name)
-            dep = "Using the :class locator to locate multiple classes with a String value (i.e. \"#{class_name}\")"
-            Watir.logger.deprecate dep,
-                                   "Array (e.g. #{class_name.split})",
-                                   ids: [:class_array]
-          end
-
           def visible?
             !(@built.keys & CAN_NOT_BUILD).empty?
           end

data/lib/watir/locators/row/selector_builder.rb

@@ -2,13 +2,13 @@ module Watir
   module Locators
     class Row
       class SelectorBuilder < Element::SelectorBuilder
-        def initialize(valid_attributes, scope_tag_name)
-          @scope_tag_name = scope_tag_name
-          super(valid_attributes)
+        def build_wd_selector(selector)
+          scope_tag_name = @query_scope.selector[:tag_name] || @query_scope.tag_name
+          Kernel.const_get("#{self.class.name}::XPath").new.build(selector, scope_tag_name)
         end
 
-        def build_wd_selector(selector)
-          Kernel.const_get("#{self.class.name}::XPath").new.build(selector, @scope_tag_name)
+        def use_scope?
+          false
         end
       end
     end

data/lib/watir/locators/text_area/selector_builder.rb

@@ -2,20 +2,6 @@ module Watir
   module Locators
     class TextArea
       class SelectorBuilder < Element::SelectorBuilder
-        private
-
-        def normalize_locator(how, what)
-          # We need to iterate through located elements and fetch
-          # attribute value using Selenium because XPath doesn't understand
-          # difference between IDL vs content attribute.
-          # Current Element design doesn't allow to do that in any
-          # obvious way except to use regular expression.
-          if how == :value && what.is_a?(String)
-            [how, Regexp.new('^' + Regexp.escape(what) + '$')]
-          else
-            super
-          end
-        end
       end
     end
   end

data/lib/watir/locators/text_area/selector_builder/xpath.rb

@@ -6,10 +6,10 @@ module Watir
           private
 
           # value always requires a wire call since we want the property not the attribute
-          def predicate_conversion(key, regexp)
+          def process_attribute(key, value)
             return super unless key == :value
 
-            @built[:value] = regexp
+            @built[:value] = value
             nil
           end
         end

data/lib/watir/locators/text_field/matcher.rb

@@ -0,0 +1,38 @@
+module Watir
+  module Locators
+    class TextField
+      class Matcher < Element::Matcher
+        private
+
+        def elements_match?(element, values_to_match)
+          case element.tag_name.downcase
+          when 'input'
+            %i[text label visible_text].each do |key|
+              next unless values_to_match.key?(key)
+
+              values_to_match[:value] = values_to_match.delete(key)
+            end
+          when 'label'
+            %i[value label].each do |key|
+              next unless values_to_match.key?(key)
+
+              values_to_match[:text] = values_to_match.delete(key)
+            end
+          else
+            return
+          end
+
+          super
+        end
+
+        def text_regexp_deprecation(*)
+          # does not apply to text_field
+        end
+
+        def validate_tag(element, _tag_name)
+          matches_values?(element.tag_name.downcase, 'input')
+        end
+      end
+    end
+  end
+end

data/lib/watir/radio_set.rb

@@ -46,13 +46,12 @@ module Watir
     #
 
     def radio(opt = {})
-      n = name
-      if !n.empty? && (!opt[:name] || opt[:name] == n)
-        frame.radio(opt.merge(name: n))
-      elsif n.empty?
-        return source
+      if !name.empty? && (!opt[:name] || opt[:name] == name)
+        frame.radio(opt.merge(name: name))
+      elsif name.empty?
+        source
       else
-        raise UnknownObjectException, "#{opt[:name]} does not match name of RadioSet: #{n}"
+        raise UnknownObjectException, "#{opt[:name]} does not match name of RadioSet: #{name}"
       end
     end
 
@@ -61,13 +60,12 @@ module Watir
     #
 
     def radios(opt = {})
-      n = name
-      if !n.empty? && (!opt[:name] || opt[:name] == n)
-        element_call(:wait_for_present) { frame.radios(opt.merge(name: n)) }
-      elsif n.empty?
-        RadioCollection.new(frame, element: source.wd)
+      if !name.empty? && (!opt[:name] || opt[:name] == name)
+        element_call(:wait_for_present) { frame.radios(opt.merge(name: name)) }
+      elsif name.empty?
+        single_radio_collection
       else
-        raise UnknownObjectException, "#{opt[:name]} does not match name of RadioSet: #{n}"
+        raise UnknownObjectException, "#{opt[:name]} does not match name of RadioSet: #{name}"
       end
     end
 
@@ -132,18 +130,14 @@ module Watir
     #
 
     def select(str_or_rx)
-      found_by_value = radio(value: str_or_rx)
-      found_by_text = radio(label: str_or_rx)
-
-      if found_by_value.exist?
-        found_by_value.click unless found_by_value.selected?
-        return found_by_value.value
-      elsif found_by_text.exist?
-        found_by_text.click unless found_by_text.selected?
-        return found_by_text.text
-      else
-        raise UnknownObjectException, "Unable to locate radio matching #{str_or_rx.inspect}"
+      %i[value label].each do |key|
+        radio = radio(key => str_or_rx)
+        next unless radio.exist?
+
+        radio.click unless radio.selected?
+        return key == :value ? radio.value : radio.text
       end
+      raise UnknownObjectException, "Unable to locate radio matching #{str_or_rx.inspect}"
     end
 
     #
@@ -156,7 +150,6 @@ module Watir
 
     def selected?(str_or_rx)
       found = frame.radio(label: str_or_rx)
-
       return found.selected? if found.exist?
 
       raise UnknownObjectException, "Unable to locate radio matching #{str_or_rx.inspect}"
@@ -170,8 +163,7 @@ module Watir
     #
 
     def value
-      sel = selected
-      sel&.value
+      selected&.value
     end
 
     #
@@ -182,8 +174,7 @@ module Watir
     #
 
     def text
-      sel = selected
-      sel&.text
+      selected&.text
     end
 
     #
@@ -206,9 +197,7 @@ module Watir
     #
 
     def ==(other)
-      return false unless other.is_a?(self.class)
-
-      radios == other.radios
+      other.is_a?(self.class) && radios == other.radios
     end
     alias eql? ==
 
@@ -218,6 +207,14 @@ module Watir
         source.send(method, *args, &blk)
       end
     end
+
+    private
+
+    def single_radio_collection
+      collection = RadioCollection.new(frame, source.selector)
+      collection.first.cache = source.wd
+      collection
+    end
   end # RadioSet
 
   module Container

data/lib/watir/scroll.rb

@@ -0,0 +1,69 @@
+module Watir
+  module Scrolling
+    def scroll
+      Scroll.new(self)
+    end
+  end
+
+  class Scroll
+    def initialize(object)
+      @object = object
+    end
+
+    # Scrolls by offset.
+    # @param [Fixnum] left Horizontal offset
+    # @param [Fixnum] top Vertical offset
+    #
+    def by(left, top)
+      @object.browser.execute_script('window.scrollBy(arguments[0], arguments[1]);', Integer(left), Integer(top))
+      self
+    end
+
+    #
+    # Scrolls to specified location.
+    # @param [Symbol] param
+    #
+    def to(param = :top)
+      args = @object.is_a?(Watir::Element) ? element_scroll(param) : browser_scroll(param)
+      raise ArgumentError, "Don't know how to scroll #{@object} to: #{param}!" if args.nil?
+
+      @object.browser.execute_script(*args)
+      self
+    end
+
+    private
+
+    def element_scroll(param)
+      script = case param
+               when :top, :start
+                 'arguments[0].scrollIntoView();'
+               when :center
+                 <<-JS
+                   var bodyRect = document.body.getBoundingClientRect();
+                   var elementRect = arguments[0].getBoundingClientRect();
+                   var left = (elementRect.left - bodyRect.left) - (window.innerWidth / 2);
+                   var top = (elementRect.top - bodyRect.top) - (window.innerHeight / 2);
+                   window.scrollTo(left, top);
+                 JS
+               when :bottom, :end
+                 'arguments[0].scrollIntoView(false);'
+               else
+                 return nil
+               end
+      [script, @object]
+    end
+
+    def browser_scroll(param)
+      case param
+      when :top, :start
+        'window.scrollTo(0, 0);'
+      when :center
+        'window.scrollTo(window.outerWidth / 2, window.outerHeight / 2);'
+      when :bottom, :end
+        'window.scrollTo(0, document.body.scrollHeight);'
+      when Array
+        ['window.scrollTo(arguments[0], arguments[1]);', Integer(param[0]), Integer(param[1])]
+      end
+    end
+  end
+end

data/lib/watir/version.rb

@@ -1,3 +1,3 @@
 module Watir
-  VERSION = '6.15.1'.freeze
+  VERSION = '6.16.0'.freeze
 end

data/spec/locator_spec_helper.rb

@@ -1,17 +1,40 @@
 module LocatorSpecHelper
   def browser
-    @browser ||= double(Watir::Browser, wd: driver)
+    @browser ||= instance_double(Watir::Browser, wd: driver)
+    allow(@browser).to receive(:browser).and_return(@browser)
+    allow(@browser).to receive(:is_a?).with(Watir::Browser).and_return(true)
+    allow(@browser).to receive(:locator_namespace).and_return(@locator_namespace || Watir::Locators)
+    @browser
   end
 
   def driver
-    @driver ||= double(Selenium::WebDriver::Driver)
+    @driver ||= instance_double(Selenium::WebDriver::Driver)
   end
 
-  def locator(selector, attrs)
-    attrs ||= Watir::HTMLElement.attributes
-    element_validator = Watir::Locators::Element::Validator.new
-    selector_builder = Watir::Locators::Element::SelectorBuilder.new(attrs)
-    Watir::Locators::Element::Locator.new(browser, selector, selector_builder, element_validator)
+  def selector_builder
+    @built ||= {xpath: ''}
+    @selector_builder = instance_double(Watir::Locators::Element::SelectorBuilder)
+    allow(@selector_builder).to receive(:build).and_return(@built)
+    @selector_builder
+  end
+
+  def attributes
+    @attributes ||=  Watir::HTMLElement.attribute_list
+  end
+
+  def query_scope
+    @query_scope ||= browser
+  end
+
+  def element_matcher
+    @element_matcher ||= instance_double(Watir::Locators::Element::Matcher)
+    allow(@element_matcher).to receive(:query_scope).and_return(browser)
+    allow(@element_matcher).to receive(:selector).and_return(@locator || {})
+    @element_matcher
+  end
+
+  def locator
+    Watir::Locators::Element::Locator.new(element_matcher)
   end
 
   def expect_one(*args)
@@ -22,25 +45,46 @@ module LocatorSpecHelper
     expect(driver).to receive(:find_elements).with(*args)
   end
 
-  def locate_one(selector, attrs = nil)
-    locator(ordered_hash(selector), attrs).locate
+  def locate_one(selector = nil)
+    selector ||= @locator || {}
+    locator.locate ordered_hash(selector)
+  end
+
+  def locate_all(selector = nil)
+    selector ||= @locator || {}
+    locator.locate_all ordered_hash(selector)
   end
 
-  def locate_all(selector, attrs = nil)
-    locator(ordered_hash(selector), attrs).locate_all
+  def selector_build(selector)
+    selector_builder.build(selector)
   end
 
   def element(opts = {})
-    attrs = opts.delete(:attributes)
-    el = double(Watir::HTMLElement, opts)
+    raise unless opts.delete(:attributes).nil?
+
+    klass = opts.delete(:watir_element) || Watir::HTMLElement
+    el = instance_double(klass, opts)
+
+    allow(el).to receive(:enabled?).and_return true
+    allow(el).to receive(:selector_builder).and_return(selector_builder)
+    allow(el).to receive(:wd).and_return wd_element unless opts.key?(:wd)
+    allow(el).to receive(:selector).and_return(@selector || {})
+    el
+  end
 
+  def wd_element(opts = {})
+    attrs = opts.delete(:attributes)
+    el = instance_double(Selenium::WebDriver::Element, opts)
     attrs&.each do |key, value|
       allow(el).to receive(:attribute).with(key.to_s).and_return(value)
     end
-    allow(el).to receive(:enabled?).and_return true
     el
   end
 
+  def el
+    @el ||= wd_element
+  end
+
   def ordered_hash(selector)
     case selector
     when Hash

data/spec/unit/element_locator_spec.rb

@@ -3,627 +3,82 @@ require_relative 'unit_helper'
 describe Watir::Locators::Element::Locator do
   include LocatorSpecHelper
 
-  describe 'finds a single element' do
-    describe 'by delegating to Selenium' do
-      SELENIUM_SELECTORS.each do |loc|
-        it "delegates to Selenium's #{loc} locator" do
-          expect_one(loc, 'bar').and_return(element(tag_name: 'div'))
-          match = %i[link link_text partial_link_text].include?(loc) ? :to : :to_not
-          msg = /:#{loc} locator is deprecated\. Use :visible_text instead/
-          expect { locate_one loc => 'bar' }.send(match, output(msg).to_stdout_from_any_process)
-        end
-      end
-
-      it 'raises exception if locating a non-link element by link locator' do
-        selector = {tag_name: 'div', link_text: 'foo'}
-        msg = 'Can not use link_text locator to find a foo element'
-        expect {
-          expect { locate_one(selector) }.to raise_exception(StandardError, msg)
-        }.to have_deprecated_link_text
-      end
-    end
-
-    describe 'with selectors not supported by Selenium' do
-      it 'handles selector with tag name and a single attribute' do
-        expect_one :xpath, ".//*[local-name()='div'][@title='foo']"
-
-        locate_one tag_name: 'div',
-                   title: 'foo'
-      end
-
-      it 'handles selector with no tag name and and a single attribute' do
-        expect_one :xpath, ".//*[@title='foo']"
-
-        locate_one title: 'foo'
-      end
-
-      it 'handles single quotes in the attribute string' do
-        expect_one :xpath, %{.//*[@title=concat('foo and ',"'",'bar',"'",'')]}
-
-        locate_one title: "foo and 'bar'"
-      end
-
-      it 'handles selector with tag name and multiple attributes' do
-        expect_one :xpath, ".//*[local-name()='div'][@title='foo' and @dir='bar']"
-
-        locate_one [:tag_name, 'div',
-                    :title, 'foo',
-                    :dir, 'bar']
-      end
-
-      it 'handles selector with no tag name and multiple attributes' do
-        expect_one :xpath, ".//*[@dir='foo' and @title='bar']"
-
-        locate_one [:dir,   'foo',
-                    :title, 'bar']
-      end
-
-      it 'handles selector with attribute presence' do
-        expect_one :xpath, './/*[@data-view]'
-
-        locate_one [:data_view, true]
-      end
-
-      it 'handles selector with attribute absence' do
-        expect_one :xpath, './/*[not(@data-view)]'
-
-        locate_one [:data_view, false]
-      end
-
-      it 'handles selector with class attribute presence' do
-        expect_one :xpath, './/*[@class]'
-
-        locate_one class: true
-      end
-
-      it 'handles selector with multiple classes in array' do
-        xpath = ".//*[contains(concat(' ', @class, ' '), ' a ') and contains(concat(' ', @class, ' '), ' b ')]"
-        expect_one :xpath, xpath
-
-        locate_one class: %w[a b]
-      end
-
-      it 'handles selector with multiple classes in string' do
-        expect_one :xpath, ".//*[contains(concat(' ', @class, ' '), ' a b ')]"
-
-        expect { locate_one class: 'a b' }.to have_deprecated_class_array
-      end
-
-      it 'handles selector with xpath and tag_name String' do
-        elements = [
-          element(tag_name: 'div', attributes: {class: 'foo'}),
-          element(tag_name: 'span', attributes: {class: 'foo'}),
-          element(tag_name: 'div', attributes: {class: 'foo'})
-        ]
-
-        expect_all(:xpath, './/*[@class="foo"]').and_return(elements)
-
-        selector = {
-          xpath: './/*[@class="foo"]',
-          tag_name: 'span'
-        }
-
-        expect(locate_one(selector).tag_name).to eq 'span'
-      end
-
-      it 'handles selector with xpath and tag_name Symbol' do
-        elements = [
-          element(tag_name: 'div', attributes: {class: 'foo'}),
-          element(tag_name: 'span', attributes: {class: 'foo'}),
-          element(tag_name: 'div', attributes: {class: 'foo'})
-        ]
-
-        expect_all(:xpath, './/*[@class="foo"]').and_return(elements)
-
-        selector = {
-          xpath: './/*[@class="foo"]',
-          tag_name: 'span'
-        }
-
-        expect(locate_one(selector).tag_name).to eq 'span'
-      end
-
-      it 'handles custom attributes' do
-        elements = [
-          element(tag_name: 'div', attributes: {custom_attribute: 'foo'}),
-          element(tag_name: 'span', attributes: {custom_attribute: 'foo'}),
-          element(tag_name: 'div', attributes: {custom_attribute: 'foo'})
-        ]
-
-        expect_one(:xpath, ".//*[local-name()='span'][@custom-attribute='foo']").and_return(elements[1])
-
-        selector = {
-          custom_attribute: 'foo',
-          tag_name: 'span'
-        }
-
-        expect(locate_one(selector).tag_name).to eq 'span'
-      end
-    end
-
-    describe 'with special cased selectors' do
-      it 'normalizes space for :text' do
-        expect_one :xpath, ".//*[local-name()='div'][normalize-space()='foo']"
-        locate_one tag_name: 'div',
-                   text: 'foo'
-      end
-
-      # TODO: This is deprecated by 'text_string'
-      it "handles 'text' key when it's a string" do
-        expect_one :xpath, ".//*[local-name()='div'][normalize-space()='foo']"
-        locate_one tag_name: 'div',
-                   'text' => 'foo'
-      end
-
-      it 'translates :caption to :text' do
-        expect_one :xpath, ".//*[local-name()='div'][normalize-space()='foo']"
-
-        locate_one tag_name: 'div',
-                   caption: 'foo'
-      end
-
-      it 'handles data-* attributes' do
-        expect_one :xpath, ".//*[local-name()='div'][@data-name='foo']"
-
-        locate_one tag_name: 'div',
-                   data_name: 'foo'
-      end
-
-      it 'handles aria-* attributes' do
-        expect_one :xpath, ".//*[local-name()='div'][@aria-label='foo']"
-
-        locate_one tag_name: 'div',
-                   aria_label: 'foo'
-      end
-
-      it "doesn't modify attribute name when the attribute key is a string" do
-        expect_one :xpath, ".//*[local-name()='div'][@_ngcontent-c24]"
-
-        locate_one tag_name: 'div',
-                   '_ngcontent-c24' => true
-      end
-
-      it 'normalizes space for the :href attribute' do
-        expect_one :xpath, ".//*[local-name()='a'][normalize-space(@href)='foo']"
-
-        selector = {
-          tag_name: 'a',
-          href: 'foo'
-        }
-
-        locate_one selector, Watir::Anchor.attributes
-      end
-
-      it 'wraps :type attribute with translate() for upper case values' do
-        translated_type = "translate(@type,'ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞŸŽŠŒ'," \
-"'abcdefghijklmnopqrstuvwxyzàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿžšœ')"
-        expect_one :xpath, ".//*[local-name()='input'][#{translated_type}='file']"
-
-        selector = [
-          :tag_name, 'input',
-          :type, 'file'
-        ]
-
-        locate_one selector, Watir::Input.attributes
-      end
-
-      it "uses the corresponding <label>'s @for attribute or parent::label when locating by label" do
-        translated_type = "translate(@type,'ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞŸŽŠŒ'," \
-"'abcdefghijklmnopqrstuvwxyzàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿžšœ')"
-        xpath = ".//*[local-name()='input'][@id=//label[normalize-space()='foo']/@for " \
-"or parent::label[normalize-space()='foo']][#{translated_type}='text']"
-        expect_one :xpath, xpath
-
-        selector = [
-          :tag_name, 'input',
-          :type, 'text',
-          :label, 'foo'
-        ]
-
-        locate_one selector, Watir::Input.attributes
-      end
-
-      it 'uses label attribute if it is valid for element' do
-        expect_one :xpath, ".//*[local-name()='option'][@label='foo']"
-
-        selector = {tag_name: 'option', label: 'foo'}
-        locate_one selector, Watir::Option.attributes
-      end
-
-      it 'translates ruby attribute names to content attribute names' do
-        expect_one :xpath, ".//*[local-name()='meta'][@http-equiv='foo']"
-
-        selector = {
-          tag_name: 'meta',
-          http_equiv: 'foo'
-        }
-
-        locate_one selector, Watir::Meta.attributes
-      end
-    end
-
-    describe 'with simple regexp selectors' do
-      it 'handles selector with tag name and a simple regexp attribute' do
-        element = element(tag_name: 'div', attributes: {class: 'foob'})
-
-        expect_one(:xpath, ".//*[local-name()='div'][contains(@class, 'oob')]").and_return(element)
-
-        expect(locate_one(tag_name: 'div', class: /oob/)).to eq element
-      end
-
-      it 'handles :tag_name, :index and a simple regexp attribute' do
-        element = element(tag_name: 'div', attributes: {class: 'foo'})
-
-        expect_one(:xpath, "(.//*[local-name()='div'][contains(@class, 'foo')])[2]").and_return(element)
-
-        selector = {
-          tag_name: 'div',
-          class: /foo/,
-          index: 1
-        }
-
-        expect(locate_one(selector)).to eq element
-      end
-
-      it 'handles :xpath and :index selectors' do
-        elements = [
-          element(tag_name: 'div', attributes: {class: 'foo'}),
-          element(tag_name: 'div', attributes: {class: 'foo'})
-        ]
-
-        expect_all(:xpath, './/div[@class="foo"]').and_return(elements)
-
-        selector = {
-          xpath: './/div[@class="foo"]',
-          index: 1
-        }
-
-        expect(locate_one(selector)).to eq elements[1]
-      end
-
-      it 'handles :css and :index selectors' do
-        elements = [
-          element(tag_name: 'div', attributes: {class: 'foo'}),
-          element(tag_name: 'div', attributes: {class: 'foo'})
-        ]
-
-        expect_all(:css, 'div[class="foo"]').and_return(elements)
-
-        selector = {
-          css: 'div[class="foo"]',
-          index: 1
-        }
-
-        expect(locate_one(selector)).to eq elements[1]
-      end
-
-      it 'handles mix of string and regexp attributes' do
-        element = element(tag_name: 'div', attributes: {dir: 'foo', title: 'baz'})
+  describe '#locate' do
+    context 'when XPath can be built to represent entire selector' do
+      it 'locates without using match' do
+        @locator = {xpath: './/div'}
 
-        expect_one(:xpath, ".//*[local-name()='div'][@dir='foo' and contains(@title, 'baz')]").and_return(element)
+        expect_one(*@locator.to_a.flatten).and_return(el)
+        expect(element_matcher).not_to receive(:match)
 
-        selector = {
-          tag_name: 'div',
-          dir: 'foo',
-          title: /baz/
-        }
-
-        expect(locate_one(selector)).to eq element
-      end
-
-      it 'handles data-* attributes with regexp' do
-        element = element(tag_name: 'div', attributes: {'data-automation-id': 'bar'})
-
-        expect_one(:xpath, ".//*[local-name()='div'][contains(@data-automation-id, 'bar')]").and_return(element)
-
-        selector = {
-          tag_name: 'div',
-          data_automation_id: /bar/
-        }
-
-        expect(locate_one(selector)).to eq element
+        expect(locate_one).to eq el
       end
 
-      # TODO: I can not figure out how to mock this out properly with the new implementation
-      xit 'handles :label => /regexp/ selector' do
-        label_elements = [
-          element(tag_name: 'label', text: 'foo', attributes: {'for' => 'bar'}),
-          element(tag_name: 'label', text: 'foob', attributes: {'for' => 'baz'})
-        ]
-        div_elements = [element(tag_name: 'div')]
+      it 'returns nil if not found' do
+        @locator = {xpath: './/div'}
 
-        expect_all(:tag_name, 'label').ordered.and_return(label_elements)
-        expect_one(:xpath, ".//*[local-name()='div'][@id='baz']").ordered.and_return(div_elements.first)
-
-        allow(browser).to receive(:ensure_context).and_return(nil)
-        allow(browser).to receive(:execute_script).and_return('foo', 'foob')
-
-        expect(locate_one(tag_name: 'div', label: /oob/)).to eq div_elements.first
-      end
-
-      # TODO: I can not figure out how to mock this out properly with the new implementation
-      xit 'returns nil when no label matching the regexp is found' do
-        expect_all(:tag_name, 'label').and_return([])
-        expect(locate_one(tag_name: 'div', label: /foo/)).to be_nil
-      end
-
-      it 'relocates an element that goes stale during filtering' do
-        element1 = element(tag_name: 'div', attributes: {class: 'foo'})
-        element2 = element(tag_name: 'div', attributes: {class: 'foob'})
-
-        elements1 = [element1.clone, element2.clone]
-        elements2 = [element1.clone, element2.clone]
-
-        allow(elements1.first).to receive(:attribute).and_raise(Selenium::WebDriver::Error::StaleElementReferenceError)
-
-        expect_all(:xpath, ".//*[contains(@class, 'foo')]").and_return(elements1, elements2)
-
-        expect(locate_one(class: /foo$/)).to eq elements2[0]
-      end
-
-      it 'raises error if too many attempts to relocate a stale element during filtering' do
-        element1 = element(tag_name: 'div', attributes: {class: 'foo'})
-        element2 = element(tag_name: 'div', attributes: {class: 'foob'})
-
-        elements1 = [element1.clone, element2.clone]
-        elements2 = [element1.clone, element2.clone]
-        elements3 = [element1.clone, element2.clone]
-
-        allow(elements1.first).to receive(:attribute).and_raise(Selenium::WebDriver::Error::StaleElementReferenceError)
-        allow(elements2.first).to receive(:attribute).and_raise(Selenium::WebDriver::Error::StaleElementReferenceError)
-        allow(elements3.first).to receive(:attribute).and_raise(Selenium::WebDriver::Error::StaleElementReferenceError)
-
-        expect_all(:xpath, ".//*[contains(@class, 'foo')]").and_return(elements1, elements2, elements3)
-
-        msg = 'Unable to locate element from {:class=>/foo$/} due to changing page'
-        expect { locate_one(class: /foo$/) }.to raise_exception(Watir::Exception::LocatorException, msg)
+        expect_one(*@locator.to_a.flatten).and_raise(Selenium::WebDriver::Error::NoSuchElementError)
+        expect(locate_one).to eq nil
       end
     end
 
-    it "returns nil if found element didn't match the selector tag_name" do
-      expect_all(:xpath, '//div').and_return([element(tag_name: 'div')])
-
-      selector = {
-        tag_name: 'input',
-        xpath: '//div'
-      }
+    context 'when SelectorBuilder result has additional locators to match' do
+      it 'locates using match' do
+        @locator = {xpath: './/div', id: 'foo'}
 
-      expect(locate_one(selector, Watir::Input.attributes)).to be_nil
-    end
+        expect_all(*@locator.to_a.first.flatten).and_return([el])
+        expect(element_matcher).to receive(:match).and_return(el)
 
-    it 'allows tag_name values to be Symbols when combined with xpath' do
-      expect_all(:xpath, '//div').and_return([element(tag_name: 'div')])
-
-      selector = {
-        tag_name: :input,
-        xpath: '//div'
-      }
-
-      expect(locate_one(selector, Watir::Input.attributes)).to be_nil
-    end
-
-    describe 'errors' do
-      it 'raises a TypeError if :index is not a Integer' do
-        msg = /expected one of \[(Integer|Fixnum)\], got "bar":String/
-        expect { locate_one(tag_name: 'div', index: 'bar') }.to raise_error TypeError, msg
+        expect(locate_one).to eq el
       end
 
-      it 'raises a TypeError if selector value is not a String, Regexp or Boolean' do
-        msg = /expected one of \[String, Regexp, TrueClass, FalseClass\], got 123:(Integer|Fixnum)/
-        expect { locate_one(foo: 123) }.to raise_error TypeError, msg
-      end
+      it 'relocates if element goes stale' do
+        @locator = {xpath: './/div', id: 'foo'}
 
-      it 'raises a Error if selector key is not a String or a Symbol' do
-        msg = /Unable to build XPath using 7:(Integer|Fixnum)/
-        expect { locate_one(7 => 'bad') }.to raise_exception(Watir::Exception::Error, msg)
-      end
+        expect_all(*@locator.to_a.first.flatten).exactly(2).times.and_return([el])
+        stale_exception = Selenium::WebDriver::Error::StaleElementReferenceError
+        expect(element_matcher).to receive(:match).and_raise(stale_exception)
+        expect(element_matcher).to receive(:match).and_return(el)
 
-      it 'raises a Error if selector key is not a String or a Symbol' do
-        msg = /Unable to build XPath using 7:(Integer|Fixnum)/
-        expect { locate_one(7 => 'bad') }.to raise_exception(Watir::Exception::Error, msg)
+        expect(locate_one).to eq el
       end
 
-      it 'raises an Error if unable to build selector' do
-        module Foo
-          class SelectorBuilder < Watir::Locators::Element::SelectorBuilder
-            def build(*_args)
-              nil
-            end
-          end
-        end
+      it 'Raises Exception if element continues to go stale' do
+        @locator = {xpath: './/div', id: 'foo'}
 
-        selector = {name: 'foo'}
-        element_validator = Watir::Locators::Element::Validator.new
-        selector_builder = Foo::SelectorBuilder.new(Watir::HTMLElement.attributes)
-        locator = Watir::Locators::Element::Locator.new(browser, selector, selector_builder, element_validator)
+        expect_all(*@locator.to_a.first.flatten).exactly(3).times.and_return([el])
+        stale_exception = Selenium::WebDriver::Error::StaleElementReferenceError
+        expect(element_matcher).to receive(:match).and_raise(stale_exception).exactly(3).times
 
-        msg = 'Foo::SelectorBuilder was unable to build selector from {:name=>"foo"}'
-        expect { locator.locate }.to raise_exception(Watir::Exception::LocatorException, msg)
-      end
-
-      it 'raises an Error if unable to build values to match' do
-        module Foo
-          class SelectorBuilder < Watir::Locators::Element::SelectorBuilder
-            def build(*_args)
-              {}
-            end
-          end
-        end
-
-        selector = {name: 'foo'}
-        element_validator = Watir::Locators::Element::Validator.new
-        selector_builder = Foo::SelectorBuilder.new(Watir::HTMLElement.attributes)
-        locator = Watir::Locators::Element::Locator.new(browser, selector, selector_builder, element_validator)
-
-        msg = 'Foo::SelectorBuilder was unable to build selector from {:name=>"foo"}'
-        expect { locator.locate }.to raise_exception(Watir::Exception::LocatorException, msg)
+        msg = 'Unable to locate element from {:xpath=>".//div", :id=>"foo"} due to changing page'
+        expect { locate_one }.to raise_exception Watir::Exception::LocatorException, msg
       end
     end
   end
 
-  describe 'finds several elements' do
-    describe 'by delegating to Selenium' do
-      SELENIUM_SELECTORS.each do |loc|
-        it "delegates to Selenium's #{loc} locator" do
-          expect_all(loc, 'bar').and_return([element(tag_name: 'div')])
-          match = %i[link link_text partial_link_text].include?(loc) ? :to : :to_not
-          msg = /:#{loc} locator is deprecated\. Use :visible_text instead/
-          expect { locate_all loc => 'bar' }.send(match, output(msg).to_stdout_from_any_process)
-        end
-      end
-    end
-
-    describe 'with an empty selector' do
-      it 'finds all when an empty selctor is given' do
-        expect_all :xpath, './/*'
-        locate_all({})
-      end
-    end
-
-    describe 'with selectors not supported by Selenium' do
-      it 'handles selector with tag name and a single attribute' do
-        expect_all :xpath, ".//*[local-name()='div'][@dir='foo']"
-        locate_all tag_name: 'div',
-                   dir: 'foo'
-      end
-
-      it 'handles selector with tag name and multiple attributes' do
-        expect_all :xpath, ".//*[local-name()='div'][@dir='foo' and @title='bar']"
-        locate_all [:tag_name, 'div',
-                    :dir, 'foo',
-                    :title, 'bar']
-      end
-
-      it 'handles selector with class attribute presence' do
-        expect_all :xpath, './/*[@class]'
-
-        locate_all class: true
-      end
-
-      it 'handles selector with multiple classes in array' do
-        xpath = ".//*[contains(concat(' ', @class, ' '), ' a ') and contains(concat(' ', @class, ' '), ' b ')]"
-        expect_all :xpath, xpath
+  describe '#locate_all' do
+    it 'locates using match' do
+      @locator = {xpath: './/div', id: 'foo'}
 
-        locate_all class: %w[a b]
-      end
-
-      it 'handles selector with multiple classes in string' do
-        expect_all :xpath, ".//*[contains(concat(' ', @class, ' '), ' a b ')]"
+      expect_all(*@locator.to_a.first.flatten).and_return([el])
+      expect(element_matcher).to receive(:match).and_return([el])
 
-        expect { locate_all class: 'a b' }.to have_deprecated_class_array
-      end
+      expect(locate_all).to eq [el]
     end
 
-    describe 'with regexp selectors' do
-      it 'handles selector with tag name and a single regexp attribute' do
-        elements = [
-          element(tag_name: 'div', attributes: {class: 'foob'}),
-          element(tag_name: 'div', attributes: {class: 'doob'}),
-          element(tag_name: 'div', attributes: {class: 'noob'})
-        ]
-
-        expect_all(:xpath, ".//*[local-name()='div'][contains(@class, 'oob')]").and_return(elements)
-        expect(locate_all(tag_name: 'div', class: /oob/)).to eq elements.last(3)
-      end
-
-      it 'handles mix of string and regexp attributes' do
-        elements = [
-          element(tag_name: 'div', attributes: {dir: 'foo', title: 'baz'}),
-          element(tag_name: 'div', attributes: {dir: 'foo', title: 'bazt'})
-        ]
+    it 'raises LocatorException if element continues to go stale' do
+      @locator = {xpath: './/div', id: 'foo'}
 
-        expect_all(:xpath, ".//*[local-name()='div'][@dir='foo' and contains(@title, 'baz')]").and_return(elements)
+      expect_all(*@locator.to_a.first.flatten).exactly(3).times.and_return([el])
+      stale_exception = Selenium::WebDriver::Error::StaleElementReferenceError
+      expect(element_matcher).to receive(:match).and_raise(stale_exception).exactly(3).times
 
-        selector = {
-          tag_name: 'div',
-          dir: 'foo',
-          title: /baz/
-        }
-
-        expect(locate_all(selector)).to eq elements.last(2)
-      end
+      msg = 'Unable to locate element collection from {:xpath=>".//div", :id=>"foo"} due to changing page'
+      expect { locate_all }.to raise_exception Watir::Exception::LocatorException, msg
     end
 
-    it 'with :index' do
-      element = element(tag_name: 'div')
-
-      expect_one(:xpath, "(.//*[local-name()='div'][@dir='foo'])[2]").and_return(element)
-
-      selector = {
-        tag_name: 'div',
-        dir: 'foo',
-        index: 1
-      }
-
-      expect(locate_one(selector)).to eq element
-    end
-
-    context 'and xpath' do
-      it 'converts a leading run of regexp literals to a contains() expression' do
-        elements = [
-          element(tag_name: 'div', attributes: {foo: 'foo'}),
-          element(tag_name: 'div', attributes: {foo: 'foob'}),
-          element(tag_name: 'div', attributes: {foo: 'bar'})
-        ]
-
-        expect_all(:xpath, ".//*[local-name()='div'][contains(@foo, 'fo') and contains(@foo, 'b')]")
-          .and_return(elements.first(2))
-
-        expect(locate_one(tag_name: 'div', foo: /fo.b$/)).to eq elements[1]
-      end
-
-      it 'converts a trailing run of regexp literals to a contains() expression' do
-        elements = [
-          element(tag_name: 'div', attributes: {foo: 'foo'}),
-          element(tag_name: 'div', attributes: {foo: 'foob'})
-        ]
-
-        expect_all(:xpath, ".//*[local-name()='div'][contains(@foo, 'fo') and contains(@foo, 'b')]")
-          .and_return(elements.last(1))
-
-        expect(locate_one(tag_name: 'div', foo: /^fo.b/)).to eq elements[1]
-      end
-
-      it 'converts a leading and a trailing run of regexp literals to a contains() expression' do
-        elements = [
-          element(tag_name: 'div', attributes: {foo: 'foo'}),
-          element(tag_name: 'div', attributes: {foo: 'foob'})
-        ]
-
-        expect_all(:xpath, ".//*[local-name()='div'][contains(@foo, 'fo') and contains(@foo, 'b')]")
-          .and_return(elements.last(1))
-
-        expect(locate_one(tag_name: 'div', foo: /fo.b/)).to eq elements[1]
-      end
-
-      it 'does not try to convert case insensitive expressions' do
-        element = element(tag_name: 'div', attributes: {foo: 'foo'})
-
-        xpath = ".//*[local-name()='div'][contains(translate" \
-"(@foo,'ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞŸŽŠŒ'," \
-"'abcdefghijklmnopqrstuvwxyzàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿžšœ'), 'foob')]"
-        expect_one(:xpath, xpath).and_return(element)
-
-        expect(locate_one(tag_name: 'div', foo: /FOOB/i)).to eq element
-      end
-
-      it "does not try to convert expressions containing '|'" do
-        elements = [
-          element(tag_name: 'div', attributes: {foo: 'foo'}),
-          element(tag_name: 'div', attributes: {foo: 'foob'})
-        ]
-
-        expect_all(:xpath, ".//*[local-name()='div'][@foo]").and_return(elements.last(1))
-
-        expect(locate_one(tag_name: 'div', foo: /x|b/)).to eq elements[1]
-      end
-    end
-
-    describe 'errors' do
-      it 'raises ArgumentError if :index is given' do
-        expect { locate_all(tag_name: 'div', index: 1) }.to \
-          raise_error(ArgumentError, "can't locate all elements by :index")
-      end
+    it 'raises Argument error if using index key' do
+      expect { locate_all(index: 2) }.to raise_exception(ArgumentError, "can't locate all elements by :index")
     end
   end
 end