watir 6.14.0 → 6.15.0

data/lib/watir/window.rb

@@ -2,6 +2,9 @@ module Watir
   class Window
     include EventuallyPresent
     include Waitable
+    include Exception
+
+    attr_reader :browser
 
     def initialize(browser, selector)
       @browser = browser
@@ -15,7 +18,7 @@ module Watir
       else
         return if selector.keys.all? { |k| %i[title url index].include? k }
 
-        raise ArgumentError, "invalid window selector: #{selector.inspect}"
+        raise ArgumentError, "invalid window selector: #{selector_string}"
       end
     end
 
@@ -99,7 +102,7 @@ module Watir
     def exists?
       assert_exists
       true
-    rescue Exception::NoMatchingWindowFoundException
+    rescue NoMatchingWindowFoundException
       false
     end
 
@@ -194,8 +197,6 @@ module Watir
       @selector.inspect
     end
 
-    protected
-
     def handle
       @handle ||= locate
     end
@@ -213,7 +214,9 @@ module Watir
     end
 
     def assert_exists
-      raise(Exception::NoMatchingWindowFoundException, @selector.inspect) unless @driver.window_handles.include?(handle)
+      return if @driver.window_handles.include?(handle)
+
+      raise(NoMatchingWindowFoundException, selector_string)
     end
 
     # return a handle to the currently active window if it is still open; otherwise nil
@@ -225,8 +228,8 @@ module Watir
 
     def matches?(handle)
       @driver.switch_to.window(handle) do
-        matches_title = @selector[:title].nil? || @driver.title =~ /#{@selector[:title]}/
-        matches_url = @selector[:url].nil? || @driver.current_url =~ /#{@selector[:url]}/
+        matches_title = @selector[:title].nil? || @browser.title =~ /#{@selector[:title]}/
+        matches_url = @selector[:url].nil? || @browser.url =~ /#{@selector[:url]}/
 
         matches_title && matches_url
       end
@@ -241,7 +244,7 @@ module Watir
       begin
         wait_until(&:exists?)
       rescue Wait::TimeoutError
-        raise Exception::NoMatchingWindowFoundException, @selector.inspect
+        raise NoMatchingWindowFoundException, selector_string
       end
     end
   end # Window

data/lib/watirspec/remote_server.rb

@@ -1,5 +1,7 @@
 module WatirSpec
   class RemoteServer
+    include Watir::Exception
+
     attr_reader :server
 
     def start(port = 4444, args: [])
@@ -33,7 +35,7 @@ module WatirSpec
       end
     rescue SocketError
       # not connected to internet
-      raise Watir::Exception::Error, 'unable to find or download selenium-server-standalone jar'
+      raise Error, 'unable to find or download selenium-server-standalone jar'
     end
   end
 end

data/spec/locator_spec_helper.rb

@@ -10,7 +10,7 @@ module LocatorSpecHelper
   def locator(selector, attrs)
     attrs ||= Watir::HTMLElement.attributes
     element_validator = Watir::Locators::Element::Validator.new
-    selector_builder = Watir::Locators::Element::SelectorBuilder.new(driver, selector, attrs)
+    selector_builder = Watir::Locators::Element::SelectorBuilder.new(attrs)
     Watir::Locators::Element::Locator.new(browser, selector, selector_builder, element_validator)
   end
 

data/spec/spec_helper.rb

@@ -2,13 +2,37 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require 'coveralls'
-Coveralls.wear!
+require 'simplecov'
+require 'simplecov-console'
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new [
+  Coveralls::SimpleCov::Formatter,
+  SimpleCov::Formatter::HTMLFormatter,
+  SimpleCov::Formatter::Console
+]
+SimpleCov.start do
+  add_filter %r{/spec/}
+  add_filter 'lib/watir/elements/html_elements.rb'
+  add_filter 'lib/watir/elements/svg_elements.rb'
+  add_filter 'lib/watir/legacy_wait.rb'
+  add_filter 'lib/watirspec'
+  refuse_coverage_drop
+end
 
 require 'watir'
 require 'webdrivers'
 require 'locator_spec_helper'
 require 'rspec'
 
+if ENV['TRAVIS']
+  require 'rspec/retry'
+  RSpec.configure do |config|
+    config.verbose_retry = true
+    config.display_try_failure_messages = true
+    config.default_retry_count = 3
+    config.exceptions_to_retry = [IOError, Net::ReadTimeout]
+  end
+end
+
 SELENIUM_SELECTORS = %i[css tag_name xpath link_text partial_link_text link].freeze
 
 Watir.relaxed_locate = false if ENV['RELAXED_LOCATE'] == 'false'

data/spec/unit/anchor_locator_spec.rb

@@ -0,0 +1,68 @@
+require_relative 'unit_helper'
+
+describe Watir::Locators::Element::Locator do
+  include LocatorSpecHelper
+
+  def locator(selector, attrs)
+    attrs ||= Watir::HTMLElement.attributes
+    element_validator = Watir::Locators::Element::Validator.new
+    selector_builder = Watir::Locators::Anchor::SelectorBuilder.new(attrs)
+    Watir::Locators::Element::Locator.new(browser, selector, selector_builder, element_validator)
+  end
+
+  it 'converts :visible_text with String to :link_text' do
+    link = element(tag_name: 'a')
+    expect_one(:link_text, 'exact text').and_return(link)
+    expect(link).not_to receive(:text) # matching does not validate text
+
+    locate_one(tag_name: 'a', visible_text: 'exact text')
+  end
+
+  it 'converts :visible_text with basic Regexp to :partial_link_text' do
+    link = element(tag_name: 'a')
+    expect_one(:partial_link_text, 'partial text').and_return(link)
+    expect(link).not_to receive(:text) # matching does not validate text
+
+    locate_one(tag_name: 'a', visible_text: /partial text/)
+  end
+
+  it 'does not convert :visible_text with complex Regexp' do
+    elements = [
+      element(tag_name: 'a', text: 'other text'),
+      element(tag_name: 'a', text: 'matching complex!text')
+    ]
+    expect_all(:xpath, ".//*[local-name()='a']").and_return(elements)
+
+    expect(locate_one(tag_name: 'a', visible_text: /complex.text/)).to eq(elements[1])
+  end
+
+  it 'does not convert :visible_text with casefold Regexp' do
+    elements = [
+      element(tag_name: 'a', text: 'other text'),
+      element(tag_name: 'a', text: 'partial text')
+    ]
+    expect_all(:xpath, ".//*[local-name()='a']").and_return(elements)
+
+    expect(locate_one(tag_name: 'a', visible_text: /partial text/i)).to eq(elements[1])
+  end
+
+  it 'does not convert :visible_text with String and other locators' do
+    els = [
+      element(tag_name: 'a', attributes: {class: 'klass', name: 'abc'}, text: 'other text'),
+      element(tag_name: 'a', attributes: {class: 'klass', name: 'abc'}, text: 'exact text')
+    ]
+    expect_all(:xpath, ".//*[local-name()='a'][contains(concat(' ', @class, ' '), ' klass ')][@name]").and_return(els)
+
+    expect(locate_one(tag_name: 'a', class: 'klass', name: /a|.c/,  visible_text: 'exact text')).to eq(els[1])
+  end
+
+  it 'does not convert :visible_text with Regexp and other locators' do
+    els = [
+      element(tag_name: 'a', attributes: {class: 'klass', name: 'abc'}, text: 'other text'),
+      element(tag_name: 'a', attributes: {class: 'klass', name: 'abc'}, text: 'partial text')
+    ]
+    expect_all(:xpath, ".//*[local-name()='a'][contains(concat(' ', @class, ' '), ' klass ')][@name]").and_return(els)
+
+    expect(locate_one(tag_name: 'a', class: 'klass', name: /a|.c/, visible_text: /partial text/)).to eq(els[1])
+  end
+end

data/spec/unit/capabilities_spec.rb

@@ -0,0 +1,27 @@
+require_relative 'unit_helper'
+
+describe Watir::Capabilities do
+  describe '#ie' do
+    it 'processes options' do
+      options = {browser_attach_timeout: 1, full_page_screenshot: true}
+      caps = Watir::Capabilities.new(:ie, options: options)
+      opts = caps.to_args.last[:options]
+      expect(opts.browser_attach_timeout).to eq 1
+      expect(opts.full_page_screenshot).to be true
+    end
+
+    it 'processes args' do
+      caps = Watir::Capabilities.new(:ie, args: %w[foo bar])
+      opts = caps.to_args.last[:options]
+      expect(opts.args).to eq Set.new(%w[foo bar])
+    end
+
+    it 'processes options class' do
+      options = Selenium::WebDriver::IE::Options.new(browser_attach_timeout: 1, full_page_screenshot: true)
+      caps = Watir::Capabilities.new(:ie, options: options)
+      opts = caps.to_args.last[:options]
+      expect(opts.browser_attach_timeout).to eq 1
+      expect(opts.full_page_screenshot).to be true
+    end
+  end
+end

data/spec/unit/element_locator_spec.rb

@@ -13,6 +13,14 @@ describe Watir::Locators::Element::Locator do
           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
@@ -69,7 +77,7 @@ describe Watir::Locators::Element::Locator do
       end
 
       it 'handles selector with multiple classes in array' do
-        xpath = ".//*[(contains(concat(' ', @class, ' '), ' a ') and contains(concat(' ', @class, ' '), ' b '))]"
+        xpath = ".//*[contains(concat(' ', @class, ' '), ' a ') and contains(concat(' ', @class, ' '), ' b ')]"
         expect_one :xpath, xpath
 
         locate_one class: %w[a b]
@@ -81,7 +89,24 @@ describe Watir::Locators::Element::Locator do
         expect { locate_one class: 'a b' }.to have_deprecated_class_array
       end
 
-      it 'handles selector with tag_name and xpath' do
+      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'}),
@@ -123,6 +148,7 @@ describe Watir::Locators::Element::Locator do
                    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',
@@ -169,7 +195,8 @@ describe Watir::Locators::Element::Locator do
       end
 
       it 'wraps :type attribute with translate() for upper case values' do
-        translated_type = "translate(@type,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')"
+        translated_type = "translate(@type,'ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞŸŽŠŒ'," \
+"'abcdefghijklmnopqrstuvwxyzàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿžšœ')"
         expect_one :xpath, ".//*[local-name()='input'][#{translated_type}='file']"
 
         selector = [
@@ -181,7 +208,8 @@ describe Watir::Locators::Element::Locator do
       end
 
       it "uses the corresponding <label>'s @for attribute or parent::label when locating by label" do
-        translated_type = "translate(@type,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')"
+        translated_type = "translate(@type,'ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞŸŽŠŒ'," \
+"'abcdefghijklmnopqrstuvwxyzàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿžšœ')"
         xpath = ".//*[local-name()='input'][#{translated_type}='text' and " \
                 "(@id=//label[normalize-space()='foo']/@for or " \
                 "parent::label[normalize-space()='foo'])]"
@@ -212,30 +240,22 @@ describe Watir::Locators::Element::Locator do
         }
 
         locate_one selector, Watir::Meta.attributes
-
-        # TODO: check edge cases
       end
     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: 'foo'}),
-          element(tag_name: 'div', attributes: {class: 'foob'})
-        ]
+    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_all(:xpath, "(.//*[local-name()='div'])[contains(@class, 'oob')]").and_return(elements)
+        expect_one(:xpath, ".//*[local-name()='div'][contains(@class, 'oob')]").and_return(element)
 
-        expect(locate_one(tag_name: 'div', class: /oob/)).to eq elements[1]
+        expect(locate_one(tag_name: 'div', class: /oob/)).to eq element
       end
 
-      it 'handles :tag_name, :index and a single regexp attribute' do
-        elements = [
-          element(tag_name: 'div', attributes: {class: 'foo'}),
-          element(tag_name: 'div', attributes: {class: 'foo'})
-        ]
+      it 'handles :tag_name, :index and a simple regexp attribute' do
+        element = element(tag_name: 'div', attributes: {class: 'foo'})
 
-        expect_all(:xpath, "(.//*[local-name()='div'])[contains(@class, 'foo')]").and_return(elements)
+        expect_one(:xpath, "(.//*[local-name()='div'][contains(@class, 'foo')])[2]").and_return(element)
 
         selector = {
           tag_name: 'div',
@@ -243,7 +263,7 @@ describe Watir::Locators::Element::Locator do
           index: 1
         }
 
-        expect(locate_one(selector)).to eq elements[1]
+        expect(locate_one(selector)).to eq element
       end
 
       it 'handles :xpath and :index selectors' do
@@ -279,12 +299,9 @@ describe Watir::Locators::Element::Locator do
       end
 
       it 'handles mix of string and regexp attributes' do
-        elements = [
-          element(tag_name: 'div', attributes: {dir: 'foo', title: 'bar'}),
-          element(tag_name: 'div', attributes: {dir: 'foo', title: 'baz'})
-        ]
+        element = element(tag_name: 'div', attributes: {dir: 'foo', title: 'baz'})
 
-        expect_all(:xpath, "(.//*[local-name()='div'][@dir='foo'])[contains(@title, 'baz')]").and_return(elements)
+        expect_one(:xpath, ".//*[local-name()='div'][@dir='foo' and contains(@title, 'baz')]").and_return(element)
 
         selector = {
           tag_name: 'div',
@@ -292,23 +309,20 @@ describe Watir::Locators::Element::Locator do
           title: /baz/
         }
 
-        expect(locate_one(selector)).to eq elements[1]
+        expect(locate_one(selector)).to eq element
       end
 
       it 'handles data-* attributes with regexp' do
-        elements = [
-          element(tag_name: 'div', attributes: {'data-automation-id': 'foo'}),
-          element(tag_name: 'div', attributes: {'data-automation-id': 'bar'})
-        ]
+        element = element(tag_name: 'div', attributes: {'data-automation-id': 'bar'})
 
-        expect_all(:xpath, "(.//*[local-name()='div'])[contains(@data-automation-id, 'bar')]").and_return(elements)
+        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 elements[1]
+        expect(locate_one(selector)).to eq element
       end
 
       it 'handles :label => /regexp/ selector' do
@@ -341,28 +355,28 @@ describe Watir::Locators::Element::Locator do
 
         allow(elements1.first).to receive(:attribute).and_raise(Selenium::WebDriver::Error::StaleElementReferenceError)
 
-        expect_all(:xpath, "(.//*)[contains(@class, 'foo')]").and_return(elements1, elements2)
+        expect_all(:xpath, ".//*[contains(@class, 'foo')]").and_return(elements1, elements2)
 
-        expect(locate_one(class: /foo/)).to eq elements2[0]
+        expect(locate_one(class: /foo$/)).to eq elements2[0]
       end
-    end
 
-    it 'finds all if :index is given' do
-      # or could we use XPath indeces reliably instead?
-      elements = [
-        element(tag_name: 'div'),
-        element(tag_name: 'div')
-      ]
+      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'})
 
-      expect_all(:xpath, ".//*[local-name()='div'][@dir='foo']").and_return(elements)
+        elements1 = [element1.clone, element2.clone]
+        elements2 = [element1.clone, element2.clone]
+        elements3 = [element1.clone, element2.clone]
 
-      selector = {
-        tag_name: 'div',
-        dir: 'foo',
-        index: 1
-      }
+        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)
 
-      expect(locate_one(selector)).to eq elements[1]
+        msg = 'Unable to locate element from {:class=>[/foo$/]} due to changing page'
+        expect { locate_one(class: /foo$/) }.to raise_exception(Watir::Exception::LocatorException, msg)
+      end
     end
 
     it "returns nil if found element didn't match the selector tag_name" do
@@ -376,6 +390,17 @@ describe Watir::Locators::Element::Locator do
       expect(locate_one(selector, Watir::Input.attributes)).to be_nil
     end
 
+    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
         expect { locate_one(tag_name: 'div', index: 'bar') }.to \
@@ -383,10 +408,54 @@ describe Watir::Locators::Element::Locator do
       end
 
       it 'raises a TypeError if selector value is not a String, Regexp or Boolean' do
-        num_type = RUBY_VERSION[/^\d+\.(\d+)/, 1].to_i >= 4 ? 'Integer' : 'Fixnum'
-        msg = %(expected one of [Array, String, Regexp, TrueClass, FalseClass, Symbol], got 123:#{num_type})
-        expect { locate_one(tag_name: 123) }
-          .to raise_error TypeError, msg
+        msg = /expected one of \[String, Regexp, TrueClass, FalseClass\], got 123:(Integer|Fixnum)/
+        expect { locate_one(foo: 123) }.to raise_error TypeError, msg
+      end
+
+      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
+
+      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
+
+      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
+
+        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)
+      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#build is not returning expected responses for the current version of Watir'
+        expect { locator.locate }.to raise_exception(Watir::Exception::LocatorException, msg)
       end
     end
   end
@@ -431,7 +500,7 @@ describe Watir::Locators::Element::Locator do
       end
 
       it 'handles selector with multiple classes in array' do
-        xpath = ".//*[(contains(concat(' ', @class, ' '), ' a ') and contains(concat(' ', @class, ' '), ' b '))]"
+        xpath = ".//*[contains(concat(' ', @class, ' '), ' a ') and contains(concat(' ', @class, ' '), ' b ')]"
         expect_all :xpath, xpath
 
         locate_all class: %w[a b]
@@ -447,24 +516,22 @@ describe Watir::Locators::Element::Locator do
     describe 'with regexp selectors' do
       it 'handles selector with tag name and a single regexp attribute' do
         elements = [
-          element(tag_name: 'div', attributes: {class: 'foo'}),
           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_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: 'bar'}),
           element(tag_name: 'div', attributes: {dir: 'foo', title: 'baz'}),
           element(tag_name: 'div', attributes: {dir: 'foo', title: 'bazt'})
         ]
 
-        expect_all(:xpath, "(.//*[local-name()='div'][@dir='foo'])[contains(@title, 'baz')]").and_return(elements)
+        expect_all(:xpath, ".//*[local-name()='div'][@dir='foo' and contains(@title, 'baz')]").and_return(elements)
 
         selector = {
           tag_name: 'div',
@@ -474,64 +541,80 @@ describe Watir::Locators::Element::Locator do
 
         expect(locate_all(selector)).to eq elements.last(2)
       end
+    end
 
-      context 'and xpath' do
-        it 'converts a leading run of regexp literals to a contains() expression' do
-          elements = [
-            element(tag_name: 'div', attributes: {class: 'foo'}),
-            element(tag_name: 'div', attributes: {class: 'foob'}),
-            element(tag_name: 'div', attributes: {class: 'bar'})
-          ]
+    it 'with :index' do
+      element = element(tag_name: 'div')
 
-          expect_all(:xpath, "(.//*[local-name()='div'])[contains(@class, 'fo')]").and_return(elements.first(2))
+      expect_one(:xpath, "(.//*[local-name()='div'][@dir='foo'])[2]").and_return(element)
 
-          expect(locate_one(tag_name: 'div', class: /fo.b$/)).to eq elements[1]
-        end
+      selector = {
+        tag_name: 'div',
+        dir: 'foo',
+        index: 1
+      }
 
-        it 'converts a trailing run of regexp literals to a contains() expression' do
-          elements = [
-            element(tag_name: 'div', attributes: {class: 'foo'}),
-            element(tag_name: 'div', attributes: {class: 'foob'})
-          ]
+      expect(locate_one(selector)).to eq element
+    end
 
-          expect_all(:xpath, "(.//*[local-name()='div'])[contains(@class, 'b')]").and_return(elements.last(1))
+    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(locate_one(tag_name: 'div', class: /^fo.b/)).to eq elements[1]
-        end
+        expect_all(:xpath, ".//*[local-name()='div'][contains(@foo, 'fo') and contains(@foo, 'b')]")
+          .and_return(elements.first(2))
 
-        it 'converts a leading and a trailing run of regexp literals to a contains() expression' do
-          elements = [
-            element(tag_name: 'div', attributes: {class: 'foo'}),
-            element(tag_name: 'div', attributes: {class: 'foob'})
-          ]
+        expect(locate_one(tag_name: 'div', foo: /fo.b$/)).to eq elements[1]
+      end
 
-          expect_all(:xpath, "(.//*[local-name()='div'])[contains(@class, 'fo') and contains(@class, 'b')]")
-            .and_return(elements.last(1))
+      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(locate_one(tag_name: 'div', class: /fo.b/)).to eq elements[1]
-        end
+        expect_all(:xpath, ".//*[local-name()='div'][contains(@foo, 'fo') and contains(@foo, 'b')]")
+          .and_return(elements.last(1))
 
-        it 'does not try to convert case insensitive expressions' do
-          elements = [
-            element(tag_name: 'div', attributes: {class: 'foo'}),
-            element(tag_name: 'div', attributes: {class: 'foob'})
-          ]
+        expect(locate_one(tag_name: 'div', foo: /^fo.b/)).to eq elements[1]
+      end
 
-          expect_all(:xpath, ".//*[local-name()='div']").and_return(elements.last(1))
+      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(locate_one(tag_name: 'div', class: /FOOB/i)).to eq elements[1]
-        end
+        expect_all(:xpath, ".//*[local-name()='div'][contains(@foo, 'fo') and contains(@foo, 'b')]")
+          .and_return(elements.last(1))
 
-        it "does not try to convert expressions containing '|'" do
-          elements = [
-            element(tag_name: 'div', attributes: {class: 'foo'}),
-            element(tag_name: 'div', attributes: {class: 'foob'})
-          ]
+        expect(locate_one(tag_name: 'div', foo: /fo.b/)).to eq elements[1]
+      end
 
-          expect_all(:xpath, ".//*[local-name()='div']").and_return(elements.last(1))
+      it 'does not try to convert case insensitive expressions' do
+        element = element(tag_name: 'div', attributes: {foo: 'foo'})
 
-          expect(locate_one(tag_name: 'div', class: /x|b/)).to eq elements[1]
-        end
+        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