watir 7.0.0 → 7.2.2

data/spec/unit/match_elements/text_field_spec.rb

@@ -1,79 +1,84 @@
-require_relative '../unit_helper'
-
-describe Watir::Locators::TextField::Matcher do
-  include LocatorSpecHelper
-
-  let(:query_scope) { @query_scope || double(Watir::Browser) }
-  let(:matcher) { described_class.new(query_scope, @selector) }
-
-  describe '#match?' do
-    context 'when input element' do
-      it 'converts text to value' do
-        elements = [wd_element(tag_name: 'input', attributes: {value: 'foo'}),
-                    wd_element(tag_name: 'input', attributes: {value: 'Foob'})]
-        values_to_match = {text: 'Foob'}
-
-        expect(elements[0]).not_to receive(:text)
-        expect(elements[1]).not_to receive(:text)
-
-        expect(matcher.match(elements, values_to_match, :all)).to eq [elements[1]]
-      end
-
-      it 'converts label to value' do
-        elements = [wd_element(tag_name: 'input', attributes: {value: 'foo'}),
-                    wd_element(tag_name: 'input', attributes: {value: 'Foob'})]
-        values_to_match = {label: 'Foob'}
-
-        expect(elements[0]).not_to receive(:attribute).with(values_to_match)
-        expect(elements[1]).not_to receive(:attribute).with(values_to_match)
-
-        expect(matcher.match(elements, values_to_match, :all)).to eq [elements[1]]
-      end
-
-      it 'converts visible_text to value' do
-        elements = [wd_element(tag_name: 'input', attributes: {value: 'foo'}),
-                    wd_element(tag_name: 'input', attributes: {value: 'Foob'})]
-        values_to_match = {visible_text: 'Foob'}
-
-        expect(elements[0]).not_to receive(:attribute).with(values_to_match)
-        expect(elements[1]).not_to receive(:attribute).with(values_to_match)
+# frozen_string_literal: true
 
-        expect(matcher.match(elements, values_to_match, :all)).to eq [elements[1]]
-      end
-    end
-
-    context 'when label element' do
-      it 'converts value to text' do
-        elements = [wd_element(tag_name: 'label'),
-                    wd_element(tag_name: 'label')]
-        values_to_match = {value: 'Foob'}
-
-        allow(query_scope).to receive(:execute_script).and_return('foo', 'Foob')
-        expect(elements[0]).not_to receive(:attribute).with(values_to_match)
-        expect(elements[1]).not_to receive(:attribute).with(values_to_match)
-
-        expect(matcher.match(elements, values_to_match, :all)).to eq [elements[1]]
-      end
-
-      it 'converts label to text' do
-        elements = [wd_element(tag_name: 'label'),
-                    wd_element(tag_name: 'label')]
-        values_to_match = {label: 'Foob'}
-
-        allow(query_scope).to receive(:execute_script).and_return('foo', 'Foob')
-        expect(elements[0]).not_to receive(:attribute).with(values_to_match)
-        expect(elements[1]).not_to receive(:attribute).with(values_to_match)
+require_relative '../unit_helper'
 
-        expect(matcher.match(elements, values_to_match, :all)).to eq [elements[1]]
+module Watir
+  module Locators
+    class TextField
+      describe Matcher do
+        include LocatorSpecHelper
+
+        let(:query_scope) { @query_scope || instance_double(Watir::Browser) }
+        let(:matcher) { described_class.new(query_scope, @selector) }
+
+        describe '#match?' do
+          context 'when input element' do
+            it 'converts text to value' do
+              elements = [wd_element(tag_name: 'input', attributes: {value: 'foo'}, text: nil),
+                          wd_element(tag_name: 'input', attributes: {value: 'Foob'}, text: nil)]
+              values_to_match = {text: 'Foob'}
+
+              expect(matcher.match(elements, values_to_match, :all)).to eq [elements[1]]
+              expect(elements[0]).not_to have_received(:text)
+              expect(elements[1]).not_to have_received(:text)
+            end
+
+            it 'converts label to value' do
+              elements = [wd_element(tag_name: 'input', attributes: {value: 'foo'}),
+                          wd_element(tag_name: 'input', attributes: {value: 'Foob'})]
+              values_to_match = {label: 'Foob'}
+
+              expect(matcher.match(elements, values_to_match, :all)).to eq [elements[1]]
+              expect(elements[0]).not_to have_received(:attribute).with(values_to_match)
+              expect(elements[1]).not_to have_received(:attribute).with(values_to_match)
+            end
+
+            it 'converts visible_text to value' do
+              elements = [wd_element(tag_name: 'input', attributes: {value: 'foo'}),
+                          wd_element(tag_name: 'input', attributes: {value: 'Foob'})]
+              values_to_match = {visible_text: 'Foob'}
+
+              expect(matcher.match(elements, values_to_match, :all)).to eq [elements[1]]
+              expect(elements[0]).not_to have_received(:attribute).with(values_to_match)
+              expect(elements[1]).not_to have_received(:attribute).with(values_to_match)
+            end
+          end
+
+          context 'when label element' do
+            it 'converts value to text' do
+              elements = [wd_element(tag_name: 'label', attribute: nil),
+                          wd_element(tag_name: 'label', attribute: nil)]
+              values_to_match = {value: 'Foob'}
+
+              allow(query_scope).to receive(:execute_script).and_return('foo', 'Foob')
+              expect(elements[0]).not_to have_received(:attribute)
+              expect(elements[1]).not_to have_received(:attribute)
+
+              expect(matcher.match(elements, values_to_match, :all)).to eq [elements[1]]
+            end
+
+            it 'converts label to text' do
+              elements = [wd_element(tag_name: 'label', attribute: nil),
+                          wd_element(tag_name: 'label', attribute: nil)]
+              values_to_match = {label: 'Foob'}
+
+              allow(query_scope).to receive(:execute_script).and_return('foo', 'Foob')
+
+              expect(matcher.match(elements, values_to_match, :all)).to eq [elements[1]]
+              expect(elements[0]).not_to have_received(:attribute)
+              expect(elements[1]).not_to have_received(:attribute)
+            end
+          end
+
+          it 'returns empty array if element is not an input' do
+            elements = [wd_element(tag_name: 'wrong', text: 'foob', attributes: {value: 'foo'}),
+                        wd_element(tag_name: 'wrong', text: 'bar', attributes: {value: 'bar'})]
+            values_to_match = {tag_name: 'input', value: 'foo'}
+
+            expect(matcher.match(elements, values_to_match, :all)).to eq []
+          end
+        end
       end
     end
-
-    it 'returns empty array if element is not an input' do
-      elements = [wd_element(tag_name: 'wrong', text: 'foob', attributes: {value: 'foo'}),
-                  wd_element(tag_name: 'wrong', text: 'bar', attributes: {value: 'bar'})]
-      values_to_match = {tag_name: 'input', value: 'foo'}
-
-      expect(matcher.match(elements, values_to_match, :all)).to eq []
-    end
   end
 end

data/spec/unit/selector_builder/anchor_spec.rb

@@ -1,51 +1,59 @@
+# frozen_string_literal: true
+
 require_relative '../unit_helper'
 
-describe Watir::Locators::Anchor::SelectorBuilder do
-  include LocatorSpecHelper
+module Watir
+  module Locators
+    class Anchor
+      describe SelectorBuilder do
+        include LocatorSpecHelper
 
-  let(:selector_builder) { described_class.new(attributes, query_scope) }
+        let(:selector_builder) { described_class.new(attributes, query_scope) }
 
-  describe '#build' do
-    it 'without only tag name' do
-      selector = {tag_name: 'a'}
-      built = {xpath: ".//*[local-name()='a']"}
+        describe '#build' do
+          it 'without only tag name' do
+            selector = {tag_name: 'a'}
+            built = {xpath: ".//*[local-name()='a']"}
 
-      expect(selector_builder.build(selector)).to eq built
-    end
+            expect(selector_builder.build(selector)).to eq built
+          end
 
-    it 'converts visible_text String to link_text' do
-      selector = {tag_name: 'a', visible_text: 'Foo'}
-      built = {link_text: 'Foo'}
+          it 'converts visible_text String to link_text' do
+            selector = {tag_name: 'a', visible_text: 'Foo'}
+            built = {link_text: 'Foo'}
 
-      expect(selector_builder.build(selector)).to eq built
-    end
+            expect(selector_builder.build(selector)).to eq built
+          end
 
-    it 'converts visible_text Regexp to partial_link_text' do
-      selector = {tag_name: 'a', visible_text: /Foo/}
-      built = {partial_link_text: 'Foo'}
+          it 'converts visible_text Regexp to partial_link_text' do
+            selector = {tag_name: 'a', visible_text: /Foo/}
+            built = {partial_link_text: 'Foo'}
 
-      expect(selector_builder.build(selector)).to eq built
-    end
+            expect(selector_builder.build(selector)).to eq built
+          end
 
-    it 'does not convert visible_text with casefold Regexp to partial_link_text' do
-      selector = {tag_name: 'a', visible_text: /partial text/i}
-      built = {xpath: ".//*[local-name()='a']", visible_text: /partial text/i}
+          it 'does not convert visible_text with casefold Regexp to partial_link_text' do
+            selector = {tag_name: 'a', visible_text: /partial text/i}
+            built = {xpath: ".//*[local-name()='a']", visible_text: /partial text/i}
 
-      expect(selector_builder.build(selector)).to eq built
-    end
+            expect(selector_builder.build(selector)).to eq built
+          end
 
-    it 'does not convert :visible_text with String and other locators' do
-      selector = {tag_name: 'a', visible_text: 'Foo', id: 'Foo'}
-      built = {xpath: ".//*[local-name()='a'][@id='Foo']", visible_text: 'Foo'}
+          it 'does not convert :visible_text with String and other locators' do
+            selector = {tag_name: 'a', visible_text: 'Foo', id: 'Foo'}
+            built = {xpath: ".//*[local-name()='a'][@id='Foo']", visible_text: 'Foo'}
 
-      expect(selector_builder.build(selector)).to eq built
-    end
+            expect(selector_builder.build(selector)).to eq built
+          end
 
-    it 'does not convert :visible_text with Regexp and other locators' do
-      selector = {tag_name: 'a', visible_text: /Foo/, id: 'Foo'}
-      built = {xpath: ".//*[local-name()='a'][@id='Foo']", visible_text: /Foo/}
+          it 'does not convert :visible_text with Regexp and other locators' do
+            selector = {tag_name: 'a', visible_text: /Foo/, id: 'Foo'}
+            built = {xpath: ".//*[local-name()='a'][@id='Foo']", visible_text: /Foo/}
 
-      expect(selector_builder.build(selector)).to eq built
+            expect(selector_builder.build(selector)).to eq built
+          end
+        end
+      end
     end
   end
 end

data/spec/unit/selector_builder/button_spec.rb

@@ -1,206 +1,216 @@
-require_relative '../unit_helper'
-
-describe Watir::Locators::Button::SelectorBuilder do
-  include LocatorSpecHelper
-
-  let(:selector_builder) { described_class.new(attributes, query_scope) }
-  let(:uppercase) { 'ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞŸŽŠŒ' }
-  let(:lowercase) { 'abcdefghijklmnopqrstuvwxyzàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿžšœ' }
-  let(:default_types) do
-    "translate(@type,'#{uppercase}','#{lowercase}')=translate('button','#{uppercase}','#{lowercase}') or " \
-    "translate(@type,'#{uppercase}','#{lowercase}')=translate('reset','#{uppercase}','#{lowercase}') or "\
-    "translate(@type,'#{uppercase}','#{lowercase}')=translate('submit','#{uppercase}','#{lowercase}') or "\
-    "translate(@type,'#{uppercase}','#{lowercase}')=translate('image','#{uppercase}','#{lowercase}')"
-  end
-
-  describe '#build' do
-    it 'without any arguments' do
-      selector = {}
-      built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]"}
-      expect(selector_builder.build(selector)).to eq built
-    end
-
-    context 'with type' do
-      it 'false only locates with button without a type' do
-        selector = {type: false}
-        built = {xpath: ".//*[(local-name()='button' and not(@type))]"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'true locates button or input with a type' do
-        selector = {type: true}
-        built = {xpath: ".//*[(local-name()='button' and @type) or " \
-"(local-name()='input' and (#{default_types}))]"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'locates input or button element with specified type' do
-        selector = {type: 'reset'}
-        type = "translate('reset','#{uppercase}','#{lowercase}')"
-        built = {xpath: ".//*[(local-name()='button' and " \
-"translate(@type,'#{uppercase}','#{lowercase}')=#{type}) or " \
-"(local-name()='input' and (translate(@type,'#{uppercase}','#{lowercase}')=#{type}))]"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'raises exception when a non-button type input is specified' do
-        selector = {type: 'checkbox'}
-        msg = 'Button Elements can not be located by input type: checkbox'
-        expect { selector_builder.build(selector) }
-          .to raise_exception Watir::Exception::LocatorException, msg
-      end
-    end
-
-    context 'with xpath or css' do
-      it 'returns tag name and type to the locator' do
-        selector = {xpath: '#disabled_button', tag_name: 'input', type: 'submit'}
-        built = {xpath: '#disabled_button', tag_name: 'input', type: 'submit'}
-        expect(selector_builder.build(selector)).to eq built
-      end
-    end
-
-    context 'with text' do
-      it 'locates value of input element with String' do
-        selector = {text: 'Button'}
-        built = {xpath: ".//*[(local-name()='button' and normalize-space()='Button') or " \
-"(local-name()='input' and (#{default_types}) and @value='Button')]"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'locates text of button element with String' do
-        selector = {text: 'Button 2'}
-        built = {xpath: ".//*[(local-name()='button' and normalize-space()='Button 2') or " \
-"(local-name()='input' and (#{default_types}) and @value='Button 2')]"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'locates value of input element with simple Regexp' do
-        selector = {text: /Button/}
-        built = {xpath: ".//*[(local-name()='button' and contains(normalize-space(), 'Button')) or " \
-"(local-name()='input' and (#{default_types}) and contains(@value, 'Button'))]"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'locates text of button element with simple Regexp' do
-        selector = {text: /Button 2/}
-        built = {xpath: ".//*[(local-name()='button' and contains(normalize-space(), 'Button 2')) or " \
-"(local-name()='input' and (#{default_types}) and contains(@value, 'Button 2'))]"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'Simple Regexp for text' do
-        selector = {text: /n 2/}
-        built = {xpath: ".//*[(local-name()='button' and contains(normalize-space(), 'n 2')) or " \
-"(local-name()='input' and (#{default_types}) and contains(@value, 'n 2'))]"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'Simple Regexp for value' do
-        selector = {text: /Prev/}
-        built = {xpath: ".//*[(local-name()='button' and contains(normalize-space(), 'Prev')) or " \
-"(local-name()='input' and (#{default_types}) and contains(@value, 'Prev'))]"}
-        expect(selector_builder.build(selector)).to eq built
-      end
+# frozen_string_literal: true
 
-      it 'returns complex Regexp to the locator' do
-        selector = {text: /^foo$/}
-        built = {xpath: ".//*[(local-name()='button' and contains(normalize-space(), 'foo')) or " \
-"(local-name()='input' and (#{default_types}) and contains(@value, 'foo'))]", text: /^foo$/}
-        expect(selector_builder.build(selector)).to eq built
-      end
-    end
-
-    context 'with value' do
-      it 'input element value with String' do
-        selector = {value: 'Preview'}
-        built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]" \
-"[normalize-space()='Preview' or @value='Preview']"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'button element value with String' do
-        selector = {value: 'button_2'}
-        built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]" \
-"[normalize-space()='button_2' or @value='button_2']"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'input element value with simple Regexp' do
-        selector = {value: /Prev/}
-        built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]" \
-"[contains(normalize-space(), 'Prev') or contains(@value, 'Prev')]"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'button element value with simple Regexp' do
-        selector = {value: /on_2/}
-        built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]" \
-"[contains(normalize-space(), 'on_2') or contains(@value, 'on_2')]"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'button element text with String' do
-        selector = {value: 'Button 2'}
-        built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]" \
-"[normalize-space()='Button 2' or @value='Button 2']"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'button element text with simple Regexp' do
-        selector = {value: /ton 2/}
-        built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]" \
-"[contains(normalize-space(), 'ton 2') or contains(@value, 'ton 2')]"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'returns complex Regexp to the locator' do
-        selector = {value: /^foo$/}
-        built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]" \
-"[contains(normalize-space(), 'foo') or contains(@value, 'foo')]", value: /^foo$/}
-        expect(selector_builder.build(selector)).to eq built
-      end
-    end
-
-    context 'with index' do
-      it 'positive' do
-        selector = {index: 3}
-        built = {xpath: "(.//*[(local-name()='button') or (local-name()='input' and (#{default_types}))])[4]"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'negative' do
-        selector = {index: -4}
-        built = {xpath: "(.//*[(local-name()='button') or " \
-"(local-name()='input' and (#{default_types}))])[last()-3]"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'last' do
-        selector = {index: -1}
-        built = {xpath: "(.//*[(local-name()='button') or " \
-"(local-name()='input' and (#{default_types}))])[last()]"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'does not return index if it is zero' do
-        selector = {index: 0}
-        built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]"}
-        expect(selector_builder.build(selector)).to eq built
-      end
-
-      it 'raises exception when index is not an Integer', skip_after: true do
-        selector = {index: 'foo'}
-        msg = /expected one of \[(Integer|Fixnum)\], got "foo":String/
-        expect { selector_builder.build(selector) }.to raise_exception TypeError, msg
-      end
-    end
+require_relative '../unit_helper'
 
-    context 'with multiple locators' do
-      it 'locates using class and attributes' do
-        selector = {class: 'image', name: 'new_user_image', src: true}
-        built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]" \
-"[contains(concat(' ', @class, ' '), ' image ')][@name='new_user_image' and @src]"}
-        expect(selector_builder.build(selector)).to eq built
+module Watir
+  module Locators
+    class Button
+      describe SelectorBuilder do
+        include LocatorSpecHelper
+
+        let(:selector_builder) { described_class.new(attributes, query_scope) }
+        let(:uppercase) { 'ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞŸŽŠŒ' }
+        let(:lowercase) { 'abcdefghijklmnopqrstuvwxyzàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿžšœ' }
+        let(:default_types) do
+          "translate(@type,'#{uppercase}','#{lowercase}')=translate('button','#{uppercase}','#{lowercase}') or " \
+            "translate(@type,'#{uppercase}','#{lowercase}')=translate('reset','#{uppercase}','#{lowercase}') or " \
+            "translate(@type,'#{uppercase}','#{lowercase}')=translate('submit','#{uppercase}','#{lowercase}') or " \
+            "translate(@type,'#{uppercase}','#{lowercase}')=translate('image','#{uppercase}','#{lowercase}')"
+        end
+
+        describe '#build' do
+          it 'without any arguments' do
+            selector = {}
+            built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]"}
+            expect(selector_builder.build(selector)).to eq built
+          end
+
+          context 'with type' do
+            it 'false only locates with button without a type' do
+              selector = {type: false}
+              built = {xpath: ".//*[(local-name()='button' and not(@type))]"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'true locates button or input with a type' do
+              selector = {type: true}
+              built = {xpath: ".//*[(local-name()='button' and @type) or " \
+                              "(local-name()='input' and (#{default_types}))]"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'locates input or button element with specified type' do
+              selector = {type: 'reset'}
+              type = "translate('reset','#{uppercase}','#{lowercase}')"
+              built = {xpath: ".//*[(local-name()='button' and " \
+                              "translate(@type,'#{uppercase}','#{lowercase}')=#{type}) or " \
+                              "(local-name()='input' and (translate(@type,'#{uppercase}','#{lowercase}')=#{type}))]"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'raises exception when a non-button type input is specified' do
+              selector = {type: 'checkbox'}
+              msg = 'Button Elements can not be located by input type: checkbox'
+              expect { selector_builder.build(selector) }
+                .to raise_exception Watir::Exception::LocatorException, msg
+            end
+          end
+
+          context 'with xpath or css' do
+            it 'returns tag name and type to the locator' do
+              selector = {xpath: '#disabled_button', tag_name: 'input', type: 'submit'}
+              built = {xpath: '#disabled_button', tag_name: 'input', type: 'submit'}
+              expect(selector_builder.build(selector)).to eq built
+            end
+          end
+
+          context 'with text' do
+            it 'locates value of input element with String' do
+              selector = {text: 'Button'}
+              built = {xpath: ".//*[(local-name()='button' and normalize-space()='Button') or " \
+                              "(local-name()='input' and (#{default_types}) and @value='Button')]"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'locates text of button element with String' do
+              selector = {text: 'Button 2'}
+              built = {xpath: ".//*[(local-name()='button' and normalize-space()='Button 2') or " \
+                              "(local-name()='input' and (#{default_types}) and @value='Button 2')]"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'locates value of input element with simple Regexp' do
+              selector = {text: /Button/}
+              built = {xpath: ".//*[(local-name()='button' and contains(normalize-space(), \"Button\")) or " \
+                              "(local-name()='input' and (#{default_types}) and contains(@value, \"Button\"))]"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'locates text of button element with simple Regexp' do
+              selector = {text: /Button 2/}
+              built = {xpath: ".//*[(local-name()='button' and contains(normalize-space(), \"Button 2\")) or " \
+                              "(local-name()='input' and (#{default_types}) and contains(@value, \"Button 2\"))]"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'Simple Regexp for text' do
+              selector = {text: /n 2/}
+              built = {xpath: ".//*[(local-name()='button' and contains(normalize-space(), \"n 2\")) or " \
+                              "(local-name()='input' and (#{default_types}) and contains(@value, \"n 2\"))]"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'Simple Regexp for value' do
+              selector = {text: /Prev/}
+              built = {xpath: ".//*[(local-name()='button' and contains(normalize-space(), \"Prev\")) or " \
+                              "(local-name()='input' and (#{default_types}) and contains(@value, \"Prev\"))]"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'returns complex Regexp to the locator' do
+              selector = {text: /^foo$/}
+              built = {xpath: ".//*[(local-name()='button' and contains(normalize-space(), \"foo\")) or " \
+                              "(local-name()='input' and (#{default_types}) and contains(@value, \"foo\"))]",
+                       text: /^foo$/}
+              expect(selector_builder.build(selector)).to eq built
+            end
+          end
+
+          context 'with value' do
+            it 'input element value with String' do
+              selector = {value: 'Preview'}
+              built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]" \
+                              "[normalize-space()='Preview' or @value='Preview']"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'button element value with String' do
+              selector = {value: 'button_2'}
+              built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]" \
+                              "[normalize-space()='button_2' or @value='button_2']"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'input element value with simple Regexp' do
+              selector = {value: /Prev/}
+              built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]" \
+                              '[contains(normalize-space(), "Prev") or contains(@value, "Prev")]'}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'button element value with simple Regexp' do
+              selector = {value: /on_2/}
+              built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]" \
+                              '[contains(normalize-space(), "on_2") or contains(@value, "on_2")]'}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'button element text with String' do
+              selector = {value: 'Button 2'}
+              built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]" \
+                              "[normalize-space()='Button 2' or @value='Button 2']"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'button element text with simple Regexp' do
+              selector = {value: /ton 2/}
+              built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]" \
+                              '[contains(normalize-space(), "ton 2") or contains(@value, "ton 2")]'}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'returns complex Regexp to the locator' do
+              selector = {value: /^foo$/}
+              built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]" \
+                              '[contains(normalize-space(), "foo") or contains(@value, "foo")]', value: /^foo$/}
+              expect(selector_builder.build(selector)).to eq built
+            end
+          end
+
+          context 'with index' do
+            it 'positive' do
+              selector = {index: 3}
+              built = {xpath: "(.//*[(local-name()='button') or (local-name()='input' and (#{default_types}))])[4]"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'negative' do
+              selector = {index: -4}
+              built = {xpath: "(.//*[(local-name()='button') or " \
+                              "(local-name()='input' and (#{default_types}))])[last()-3]"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'last' do
+              selector = {index: -1}
+              built = {xpath: "(.//*[(local-name()='button') or " \
+                              "(local-name()='input' and (#{default_types}))])[last()]"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'does not return index if it is zero' do
+              selector = {index: 0}
+              built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'raises exception when index is not an Integer', skip_after: true do
+              selector = {index: 'foo'}
+              msg = /expected one of \[(Integer|Fixnum)\], got "foo":String/
+              expect { selector_builder.build(selector) }.to raise_exception TypeError, msg
+            end
+          end
+
+          context 'with multiple locators' do
+            it 'locates using class and attributes' do
+              selector = {class: 'image', name: 'new_user_image', src: true}
+              built = {xpath: ".//*[(local-name()='button') or (local-name()='input' and (#{default_types}))]" \
+                              "[contains(concat(' ', normalize-space(@class), ' '), ' image ')]" \
+                              "[@name='new_user_image' and @src]"}
+              expect(selector_builder.build(selector)).to eq built
+            end
+          end
+        end
       end
     end
   end