watir 7.2.0 → 7.2.1

data/spec/unit/match_elements/text_field_spec.rb

@@ -2,80 +2,83 @@
 
 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)
-
-        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
-
-    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)
-
-        expect(matcher.match(elements, values_to_match, :all)).to eq [elements[1]]
-      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

@@ -2,52 +2,58 @@
 
 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