watir 1.4.1 → 7.3.0

data/spec/unit/selector_builder/row_spec.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative '../unit_helper'
+
+module Watir
+  module Locators
+    class Row
+      describe SelectorBuilder do
+        include LocatorSpecHelper
+
+        let(:row_selector_builder) { described_class.new(attributes, query_scope) }
+        let(:selector_built) { row_selector_builder.build(selector).reject { |key| key == :scope } }
+        let(:selector) { @selector || {} }
+
+        describe '#build' do
+          context 'with query scopes' do
+            it 'with only table query scope' do
+              @query_scope = element(tag_name: 'table')
+
+              built = {xpath: "./*[local-name()='tr'] | ./*[local-name()='tbody']/*[local-name()='tr'] | " \
+                              "./*[local-name()='thead']/*[local-name()='tr'] | " \
+                              "./*[local-name()='tfoot']/*[local-name()='tr']"}
+
+              expect(selector_built).to eq built
+            end
+
+            it 'with tbody query scope' do
+              @query_scope = element(tag_name: 'tbody')
+              built = {xpath: "./*[local-name()='tr']"}
+
+              expect(selector_built).to eq built
+            end
+
+            it 'with thead query scope' do
+              @query_scope = element(tag_name: 'thead')
+              built = {xpath: "./*[local-name()='tr']"}
+
+              expect(selector_built).to eq built
+            end
+
+            it 'with tfoot query scope' do
+              @query_scope = element(tag_name: 'tfoot')
+              built = {xpath: "./*[local-name()='tr']"}
+
+              expect(selector_built).to eq built
+            end
+          end
+
+          context 'when tag name is specified' do
+            before do
+              @query_scope = element(tag_name: 'table')
+            end
+
+            context 'when index' do
+              it 'positive' do
+                @selector = {index: 1}
+                built = {xpath: "(./*[local-name()='tr'] | ./*[local-name()='tbody']/*[local-name()='tr'] | " \
+                                "./*[local-name()='thead']/*[local-name()='tr'] | " \
+                                "./*[local-name()='tfoot']/*[local-name()='tr'])[2]"}
+
+                expect(selector_built).to eq built
+              end
+
+              it 'negative' do
+                @selector = {index: -3}
+                built = {xpath: "(./*[local-name()='tr'] | ./*[local-name()='tbody']/*[local-name()='tr'] | " \
+                                "./*[local-name()='thead']/*[local-name()='tr'] | " \
+                                "./*[local-name()='tfoot']/*[local-name()='tr'])[last()-2]"}
+
+                expect(selector_built).to eq built
+              end
+
+              it 'last' do
+                @selector = {index: -1}
+                built = {xpath: "(./*[local-name()='tr'] | ./*[local-name()='tbody']/*[local-name()='tr'] | " \
+                                "./*[local-name()='thead']/*[local-name()='tr'] | " \
+                                "./*[local-name()='tfoot']/*[local-name()='tr'])[last()]"}
+
+                expect(selector_built).to eq built
+              end
+
+              it 'does not return index if it is zero' do
+                @selector = {index: 0}
+                built = {xpath: "./*[local-name()='tr'] | ./*[local-name()='tbody']/*[local-name()='tr'] | " \
+                                "./*[local-name()='thead']/*[local-name()='tr'] | " \
+                                "./*[local-name()='tfoot']/*[local-name()='tr']"}
+
+                expect(selector_built).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_built }.to raise_exception TypeError, msg
+              end
+            end
+
+            context 'when multiple locators' do
+              it 'attribute and class' do
+                @selector = {id: 'gregory', class: /brick/}
+                built = {xpath: "./*[local-name()='tr'][contains(@class, \"brick\")][@id='gregory'] | " \
+                                "./*[local-name()='tbody']/*[local-name()='tr']" \
+                                "[contains(@class, \"brick\")][@id='gregory'] | " \
+                                "./*[local-name()='thead']/*[local-name()='tr']" \
+                                "[contains(@class, \"brick\")][@id='gregory'] | " \
+                                "./*[local-name()='tfoot']/*[local-name()='tr']" \
+                                "[contains(@class, \"brick\")][@id='gregory']"}
+
+                expect(selector_built).to eq built
+              end
+            end
+
+            context 'when a text value' do
+              it 'returns locators that can not be directly translated' do
+                @selector = {text: 'Gregory'}
+                built = {xpath: "./*[local-name()='tr'] | ./*[local-name()='tbody']/*[local-name()='tr'] | " \
+                                "./*[local-name()='thead']/*[local-name()='tr'] | " \
+                                "./*[local-name()='tfoot']/*[local-name()='tr']", text: 'Gregory'}
+
+                expect(selector_built).to eq built
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/selector_builder/text_field_spec.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require_relative '../unit_helper'
+
+module Watir
+  module Locators
+    class TextField
+      describe SelectorBuilder do
+        include LocatorSpecHelper
+
+        let(:selector_builder) { described_class.new(attributes, query_scope) }
+        let(:uppercase) { 'ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞŸŽŠŒ' }
+        let(:lowercase) { 'abcdefghijklmnopqrstuvwxyzàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿžšœ' }
+        let(:negative_types) do
+          "translate(@type,'#{uppercase}','#{lowercase}')!=translate('file','#{uppercase}','#{lowercase}') and " \
+            "translate(@type,'#{uppercase}','#{lowercase}')!=translate('radio','#{uppercase}','#{lowercase}') and " \
+            "translate(@type,'#{uppercase}','#{lowercase}')!=translate('checkbox','#{uppercase}','#{lowercase}') and " \
+            "translate(@type,'#{uppercase}','#{lowercase}')!=translate('submit','#{uppercase}','#{lowercase}') and " \
+            "translate(@type,'#{uppercase}','#{lowercase}')!=translate('reset','#{uppercase}','#{lowercase}') and " \
+            "translate(@type,'#{uppercase}','#{lowercase}')!=translate('image','#{uppercase}','#{lowercase}') and " \
+            "translate(@type,'#{uppercase}','#{lowercase}')!=translate('button','#{uppercase}','#{lowercase}') and " \
+            "translate(@type,'#{uppercase}','#{lowercase}')!=translate('hidden','#{uppercase}','#{lowercase}') and " \
+            "translate(@type,'#{uppercase}','#{lowercase}')!=translate('range','#{uppercase}','#{lowercase}') and " \
+            "translate(@type,'#{uppercase}','#{lowercase}')!=translate('color','#{uppercase}','#{lowercase}') and " \
+            "translate(@type,'#{uppercase}','#{lowercase}')!=translate('date','#{uppercase}','#{lowercase}') and " \
+            "translate(@type,'#{uppercase}','#{lowercase}')!=translate('datetime-local','#{uppercase}','#{lowercase}')"
+        end
+
+        describe '#build' do
+          it 'without any arguments' do
+            selector = {}
+            built = {xpath: ".//*[local-name()='input'][not(@type) or (#{negative_types})]"}
+
+            expect(selector_builder.build(selector)).to eq built
+          end
+
+          context 'with type' do
+            it 'specified text field type that is text' do
+              selector = {type: 'text'}
+              built = {xpath: ".//*[local-name()='input']" \
+                              "[translate(@type,'#{uppercase}','#{lowercase}')=" \
+                              "translate('text','#{uppercase}','#{lowercase}')]"}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'specified text field type that is not text' do
+              selector = {type: 'number'}
+              built = {xpath: ".//*[local-name()='input']" \
+                              "[translate(@type,'#{uppercase}','#{lowercase}')=" \
+                              "translate('number','#{uppercase}','#{lowercase}')]"}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'true locates text field with a type specified' do
+              selector = {type: true}
+              built = {xpath: ".//*[local-name()='input'][#{negative_types}]"}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'false locates text field without type specified' do
+              selector = {type: false}
+              built = {xpath: ".//*[local-name()='input'][not(@type)]"}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'raises exception when a non-text field type input is specified' do
+              selector = {type: 'checkbox'}
+              msg = 'TextField Elements can not be located by type: checkbox'
+
+              expect { selector_builder.build(selector) }
+                .to raise_exception Watir::Exception::LocatorException, msg
+            end
+          end
+
+          context 'with index' do
+            it 'positive' do
+              selector = {index: 4}
+              built = {xpath: "(.//*[local-name()='input'][not(@type) or (#{negative_types})])[5]"}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'negative' do
+              selector = {index: -3}
+              built = {xpath: "(.//*[local-name()='input'][not(@type) or (#{negative_types})])[last()-2]"}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'last' do
+              selector = {index: -1}
+              built = {xpath: "(.//*[local-name()='input'][not(@type) or (#{negative_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()='input'][not(@type) or (#{negative_types})]"}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'raises exception when index is not an Integer' 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 wrong tag name' do
+            # TODO: Should this throw exception?
+            it 'ignores tag name' do
+              selector = {tag_name: 'div'}
+              built = {xpath: ".//*[local-name()='input'][not(@type) or (#{negative_types})]"}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+          end
+
+          context 'with text' do
+            it 'String for value' do
+              selector = {text: 'Developer'}
+              built = {xpath: ".//*[local-name()='input'][not(@type) or (#{negative_types})]", text: 'Developer'}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'Simple Regexp for value' do
+              selector = {text: /Dev/}
+              built = {xpath: ".//*[local-name()='input'][not(@type) or (#{negative_types})]", text: /Dev/}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'returns complicated Regexp to the locator as a value' do
+              selector = {text: /^foo$/}
+              built = {xpath: ".//*[local-name()='input'][not(@type) or (#{negative_types})]", text: /^foo$/}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+          end
+
+          context 'with label' do
+            it 'using String' do
+              selector = {label: 'First name'}
+              built = {xpath: ".//*[local-name()='input'][not(@type) or (#{negative_types})]" \
+                              "[@id=//label[normalize-space()='First name']" \
+                              "/@for or parent::label[normalize-space()='First name']]"}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'uses String with hidden text' do
+              selector = {label: 'With hidden text'}
+              built = {xpath: ".//*[local-name()='input'][not(@type) or (#{negative_types})]" \
+                              "[@id=//label[normalize-space()='With hidden text']" \
+                              "/@for or parent::label[normalize-space()='With hidden text']]"}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'using simple Regexp' do
+              selector = {label: /First/}
+              built = {xpath: ".//*[local-name()='input'][not(@type) or (#{negative_types})]" \
+                              '[@id=//label[contains(normalize-space(), "First")]' \
+                              '/@for or parent::label[contains(normalize-space(), "First")]]'}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+
+            it 'using complex Regexp' do
+              selector = {label: /([qa])st? name/}
+              built = {xpath: ".//*[local-name()='input'][not(@type) or (#{negative_types})]" \
+                              '[@id=//label[contains(normalize-space(), "s") and ' \
+                              'contains(normalize-space(), " name")]' \
+                              '/@for or parent::label[contains(normalize-space(), "s") ' \
+                              'and contains(normalize-space(), " name")]]',
+                       label_element: /([qa])st? name/}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+          end
+
+          context 'with multiple locators' do
+            it 'locates using tag name, class, attributes and text' do
+              selector = {text: 'Developer', class: /c/, id: true}
+              built = {xpath: ".//*[local-name()='input'][contains(@class, \"c\")]" \
+                              "[not(@type) or (#{negative_types})][@id]", text: 'Developer'}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/selector_builder/textarea_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../unit_helper'
+
+module Watir
+  module Locators
+    class TextArea
+      describe SelectorBuilder do
+        include LocatorSpecHelper
+
+        let(:selector_builder) { described_class.new(attributes, query_scope) }
+
+        describe '#build' do
+          context 'when String value' do
+            it 'returns value argument' do
+              selector = {tag_name: 'textarea', value: 'Foo'}
+              built = {xpath: ".//*[local-name()='textarea']", value: 'Foo'}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+          end
+
+          context 'when Regexp value' do
+            it 'returns value argument' do
+              selector = {tag_name: 'textarea', value: /Foo/}
+              built = {xpath: ".//*[local-name()='textarea']", value: /Foo/}
+
+              expect(selector_builder.build(selector)).to eq built
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/unit_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'watirspec/support/rspec_matchers'

data/spec/unit/wait_spec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative 'unit_helper'
+
+module Watir
+  describe Wait do
+    describe '#until' do
+      it 'waits until the block returns true' do
+        described_class.until(timeout: 0.5) { @result = true }
+        expect(@result).to be true
+      end
+
+      it 'executes block if timeout is zero' do
+        described_class.until(timeout: 0) { @result = true }
+        expect(@result).to be true
+      end
+
+      it 'times out' do
+        expect { described_class.until(timeout: 0.5) { false } }.to raise_error(Watir::Wait::TimeoutError)
+      end
+
+      it 'times out with a custom message' do
+        expect {
+          described_class.until(timeout: 0.5, message: 'oops') { false }
+        }.to raise_error(Watir::Wait::TimeoutError, 'timed out after 0.5 seconds, oops')
+      end
+
+      it 'uses provided interval' do
+        expect {
+          described_class.until(timeout: 0.4, interval: 0.2) do
+            @result = @result.nil? ? 1 : @result + 1
+            false
+          end
+        }.to raise_timeout_exception
+        expect(@result).to eq 2
+      end
+
+      it 'uses timer for waiting' do
+        timer = described_class.timer
+        allow(timer).to receive(:wait).and_call_original
+        described_class.until(timeout: 0.5) { true }
+        expect(timer).to have_received(:wait).with(0.5)
+      end
+    end
+
+    describe '#while' do
+      it 'waits while the block returns true' do
+        expect(described_class.while(timeout: 0.5) { false }).to be_nil
+      end
+
+      it 'executes block if timeout is zero' do
+        expect(described_class.while(timeout: 0) { false }).to be_nil
+      end
+
+      it 'times out' do
+        expect { described_class.while(timeout: 0.5) { true } }.to raise_error(Watir::Wait::TimeoutError)
+      end
+
+      it 'times out with a custom message' do
+        expect {
+          described_class.while(timeout: 0.5, message: 'oops') { true }
+        }.to raise_error(Watir::Wait::TimeoutError, 'timed out after 0.5 seconds, oops')
+      end
+
+      it 'uses provided interval' do
+        expect {
+          described_class.while(timeout: 0.4, interval: 0.2) do
+            @result = @result.nil? ? 1 : @result + 1
+            true
+          end
+        }.to raise_timeout_exception
+        expect(@result).to eq 2
+      end
+
+      it 'uses timer for waiting' do
+        timer = described_class.timer
+        allow(timer).to receive(:wait).and_call_original
+        described_class.while(timeout: 0.5) { false }
+        expect(timer).to have_received(:wait).with(0.5)
+      end
+    end
+
+    describe '#timer' do
+      it 'returns default timer' do
+        expect(described_class.timer).to be_a(Watir::Wait::Timer)
+      end
+    end
+
+    describe '#timer=' do
+      after { described_class.timer = nil }
+
+      it 'changes default timer' do
+        timer = Class.new
+        described_class.timer = timer
+        expect(described_class.timer).to eq(timer)
+      end
+    end
+  end
+end