watir 7.2.0 → 7.2.1

data/spec/unit/element_locator_spec.rb

@@ -2,85 +2,96 @@
 
 require_relative 'unit_helper'
 
-describe Watir::Locators::Element::Locator do
-  include LocatorSpecHelper
-
-  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(*@locator.to_a.flatten).and_return(el)
-        expect(element_matcher).not_to receive(:match)
-
-        expect(locate_one).to eq el
-      end
-
-      it 'returns nil if not found' do
-        @locator = {xpath: './/div'}
-
-        expect_one(*@locator.to_a.flatten).and_raise(Selenium::WebDriver::Error::NoSuchElementError)
-        expect(locate_one).to eq nil
-      end
-    end
-
-    context 'when SelectorBuilder result has additional locators to match' do
-      it 'locates using match' do
-        @locator = {xpath: './/div', id: 'foo'}
-
-        expect_all(*@locator.to_a.first.flatten).and_return([el])
-        expect(element_matcher).to receive(:match).and_return(el)
-
-        expect(locate_one).to eq el
-      end
-
-      it 'relocates if element goes stale' do
-        @locator = {xpath: './/div', id: 'foo'}
-
-        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)
-
-        expect(locate_one).to eq el
+module Watir
+  module Locators
+    class Element
+      describe Locator do
+        include LocatorSpecHelper
+
+        describe '#locate' do
+          context 'when XPath can be built to represent entire selector' do
+            it 'locates without using match' do
+              @locator = {xpath: './/div'}
+
+              allow(driver).to receive(:find_element).and_return(el)
+              allow(element_matcher).to receive(:match)
+
+              expect(locate_one).to eq el
+              expect(element_matcher).not_to have_received(:match)
+            end
+
+            it 'returns nil if not found' do
+              @locator = {xpath: './/div'}
+
+              allow(driver).to receive(:find_element).and_raise(Selenium::WebDriver::Error::NoSuchElementError)
+              expect(locate_one).to be_nil
+            end
+          end
+
+          context 'when SelectorBuilder result has additional locators to match' do
+            it 'locates using match' do
+              @locator = {xpath: './/div', id: 'foo'}
+
+              allow(driver).to receive(:find_elements).and_return([el])
+              allow(element_matcher).to receive(:match).and_return(el)
+
+              expect(locate_one).to eq el
+              expect(element_matcher).to have_received(:match).once
+            end
+
+            it 'relocates if element goes stale' do
+              @locator = {xpath: './/div', id: 'foo'}
+
+              allow(driver).to receive(:find_elements).and_return([el])
+              stale_exception = Selenium::WebDriver::Error::StaleElementReferenceError
+              allow(element_matcher).to receive(:match).and_invoke(proc { raise stale_exception }, proc { el })
+
+              expect(locate_one).to eq el
+              expect(element_matcher).to have_received(:match).exactly(2).times
+            end
+
+            it 'Raises Exception if element continues to go stale' do
+              @locator = {xpath: './/div', id: 'foo'}
+
+              allow(driver).to receive(:find_elements).and_return([el])
+              stale_exception = Selenium::WebDriver::Error::StaleElementReferenceError
+              allow(element_matcher).to receive(:match).and_raise(stale_exception)
+
+              msg = 'Unable to locate element from {:xpath=>".//div", :id=>"foo"} due to changing page'
+              expect { locate_one }.to raise_exception Watir::Exception::LocatorException, msg
+              expect(element_matcher).to have_received(:match).exactly(3).times
+            end
+          end
+        end
+
+        describe '#locate_all' do
+          it 'locates using match' do
+            @locator = {xpath: './/div', id: 'foo'}
+
+            allow(driver).to receive(:find_elements).and_return([el])
+            allow(element_matcher).to receive(:match).and_return([el])
+
+            expect(locate_all).to eq [el]
+            expect(element_matcher).to have_received(:match).once
+          end
+
+          it 'raises LocatorException if element continues to go stale' do
+            @locator = {xpath: './/div', id: 'foo'}
+
+            allow(driver).to receive(:find_elements).and_return([el])
+            stale_exception = Selenium::WebDriver::Error::StaleElementReferenceError
+            allow(element_matcher).to receive(:match).and_raise(stale_exception)
+
+            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
+            expect(element_matcher).to have_received(:match).exactly(3).times
+          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
-
-      it 'Raises Exception if element continues to go stale' do
-        @locator = {xpath: './/div', id: 'foo'}
-
-        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 = '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 '#locate_all' do
-    it 'locates using match' do
-      @locator = {xpath: './/div', id: 'foo'}
-
-      expect_all(*@locator.to_a.first.flatten).and_return([el])
-      expect(element_matcher).to receive(:match).and_return([el])
-
-      expect(locate_all).to eq [el]
-    end
-
-    it 'raises LocatorException if element continues to go stale' do
-      @locator = {xpath: './/div', id: 'foo'}
-
-      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 = '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 '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

data/spec/unit/match_elements/button_spec.rb

@@ -2,68 +2,75 @@
 
 require_relative '../unit_helper'
 
-describe Watir::Locators::Button::Matcher do
-  include LocatorSpecHelper
-
-  let(:query_scope) { @query_scope || double(Watir::Browser) }
-  let(:matcher) { described_class.new(query_scope, @selector) }
-
-  describe '#match' do
-    it 'value attribute matches value' do
-      elements = [wd_element(text: 'foo', attributes: {value: 'foo'}),
-                  wd_element(text: 'bar', attributes: {value: 'bar'}),
-                  wd_element(text: '', attributes: {value: 'foobar'})]
-      values_to_match = {value: 'foobar'}
-
-      expect(matcher.match(elements, values_to_match, :all)).to eq [elements[2]]
-    end
-
-    it 'returns empty array if neither value nor text match' do
-      elements = [wd_element(text: 'foo', attributes: {value: 'foo'}),
-                  wd_element(text: 'bar', attributes: {value: 'bar'}),
-                  wd_element(text: '', attributes: {value: 'foobar'})]
-      values_to_match = {value: 'nope'}
-
-      expect(matcher.match(elements, values_to_match, :all)).to eq []
-    end
-
-    it 'does not evaluate other parameters if value locator is not satisfied' do
-      elements = [wd_element(text: 'foo', attributes: {value: 'foo'}),
-                  wd_element(text: 'bar', attributes: {value: 'bar'}),
-                  wd_element(text: '', attributes: {value: 'foobar'})]
-      values_to_match = {value: 'nope', visible: true}
-      [0..2].each { |idx| expect(elements[idx]).not_to receive(:displayed?) }
-
-      expect(matcher.match(elements, values_to_match, :all)).to eq []
-    end
-
-    it 'does not calculate value if not passed in' do
-      elements = [wd_element(displayed?: true, text: 'foo', attributes: {value: 'foo'}),
-                  wd_element(displayed?: true, text: 'bar', attributes: {value: 'bar'})]
-      values_to_match = {visible: false}
-
-      expect(elements[0]).not_to receive(:text)
-      expect(elements[0]).not_to receive(:text)
-      expect(elements[1]).not_to receive(:attribute)
-      expect(elements[1]).not_to receive(:attribute)
-
-      expect(matcher.match(elements, values_to_match, :all)).to eq []
-    end
-
-    it 'returns empty array if element is not an input or button element' 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: 'button', value: 'foo'}
-
-      expect(matcher.match(elements, values_to_match, :all)).to eq []
-    end
-
-    it 'returns empty array if element is an input element with wrong type' do
-      elements = [wd_element(tag_name: 'input', text: 'foob', attributes: {value: 'foo', type: 'radio'}),
-                  wd_element(tag_name: 'input', text: 'bar', attributes: {value: 'bar', type: 'radio'})]
-      values_to_match = {tag_name: 'button', value: 'foo'}
-
-      expect(matcher.match(elements, values_to_match, :all)).to eq []
+module Watir
+  module Locators
+    class Button
+      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
+          it 'value attribute matches value' do
+            elements = [wd_element(text: 'foo', attributes: {value: 'foo'}),
+                        wd_element(text: 'bar', attributes: {value: 'bar'}),
+                        wd_element(text: '', attributes: {value: 'foobar'})]
+            values_to_match = {value: 'foobar'}
+
+            expect(matcher.match(elements, values_to_match, :all)).to eq [elements[2]]
+          end
+
+          it 'returns empty array if neither value nor text match' do
+            elements = [wd_element(text: 'foo', attributes: {value: 'foo'}),
+                        wd_element(text: 'bar', attributes: {value: 'bar'}),
+                        wd_element(text: '', attributes: {value: 'foobar'})]
+            values_to_match = {value: 'nope'}
+
+            expect(matcher.match(elements, values_to_match, :all)).to eq []
+          end
+
+          it 'does not evaluate other parameters if value locator is not satisfied' do
+            elements = [wd_element(text: 'foo', attributes: {value: 'foo'}, displayed?: nil),
+                        wd_element(text: 'bar', attributes: {value: 'bar'}, displayed?: nil),
+                        wd_element(text: '', attributes: {value: 'foobar'}, displayed?: nil)]
+
+            values_to_match = {value: 'nope', visible: true}
+            expect(matcher.match(elements, values_to_match, :all)).to eq []
+            expect(elements[0]).not_to have_received(:displayed?)
+            expect(elements[1]).not_to have_received(:displayed?)
+            expect(elements[2]).not_to have_received(:displayed?)
+          end
+
+          it 'does not calculate value if not passed in' do
+            elements = [wd_element(displayed?: true, text: 'foo', attributes: {value: 'foo'}),
+                        wd_element(displayed?: true, text: 'bar', attributes: {value: 'bar'})]
+            values_to_match = {visible: false}
+
+            expect(matcher.match(elements, values_to_match, :all)).to eq []
+            expect(elements[0]).not_to have_received(:text)
+            expect(elements[0]).not_to have_received(:text)
+            expect(elements[1]).not_to have_received(:attribute)
+            expect(elements[1]).not_to have_received(:attribute)
+          end
+
+          it 'returns empty array if element is not an input or button element' 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: 'button', value: 'foo'}
+
+            expect(matcher.match(elements, values_to_match, :all)).to eq []
+          end
+
+          it 'returns empty array if element is an input element with wrong type' do
+            elements = [wd_element(tag_name: 'input', text: 'foob', attributes: {value: 'foo', type: 'radio'}),
+                        wd_element(tag_name: 'input', text: 'bar', attributes: {value: 'bar', type: 'radio'})]
+            values_to_match = {tag_name: 'button', value: 'foo'}
+
+            expect(matcher.match(elements, values_to_match, :all)).to eq []
+          end
+        end
+      end
     end
   end
 end