watir 6.19.1 → 7.0.0.beta1

data/spec/unit/match_elements/button_spec.rb

@@ -16,19 +16,6 @@ describe Watir::Locators::Button::Matcher do
       expect(matcher.match(elements, values_to_match, :all)).to eq [elements[2]]
     end
 
-    it 'value attribute matches text' do
-      elements = [wd_element(text: 'foo', attributes: {value: 'foo'}),
-                  wd_element(text: 'bar', attributes: {value: 'bar'}),
-                  wd_element(text: 'foobar')]
-      values_to_match = {value: 'foobar'}
-
-      expect(elements[2]).not_to receive(:attribute)
-
-      expect {
-        expect(matcher.match(elements, values_to_match, :all)).to eq [elements[2]]
-      }.to have_deprecated_value_button
-    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'}),

data/spec/unit/match_elements/element_spec.rb

@@ -14,9 +14,11 @@ describe Watir::Locators::Element::Matcher do
                      wd_element(tag_name: 'input', attributes: {id: 'bfoo_id'}),
                      wd_element(tag_name: 'input', attributes: {id: 'foo_id'})]
 
-        label_wds = [wd_element(tag_name: 'label', text: 'foob'),
-                     wd_element(tag_name: 'label', text: 'bfoo'),
-                     wd_element(tag_name: 'label', text: 'foo')]
+        label_wds = [wd_element(tag_name: 'label'),
+                     wd_element(tag_name: 'label'),
+                     wd_element(tag_name: 'label')]
+
+        allow(browser).to receive(:execute_script).and_return('foob', 'Foo', 'foo')
 
         labels = [element(watir_element: Watir::Label, wd: label_wds[0], for: 'foob_id'),
                   element(watir_element: Watir::Label, wd: label_wds[1], for: 'bfoo_id'),
@@ -27,7 +29,6 @@ describe Watir::Locators::Element::Matcher do
         expect(labels[1]).not_to receive(:for)
 
         allow(query_scope).to receive(:labels).and_return(labels)
-        allow(matcher).to receive(:deprecate_text_regexp).exactly(3).times
         allow_any_instance_of(Watir::Input).to receive(:wd).and_return(input_wds[2], input_wds[2])
 
         values_to_match = {label_element: 'foo'}
@@ -44,9 +45,11 @@ describe Watir::Locators::Element::Matcher do
                   element(watir_element: Watir::Input, wd: input_wds[1]),
                   element(watir_element: Watir::Input, wd: input_wds[2])]
 
-        label_wds = [wd_element(tag_name: 'label', text: 'foob'),
-                     wd_element(tag_name: 'label', text: 'Foo'),
-                     wd_element(tag_name: 'label', text: 'foo')]
+        label_wds = [wd_element(tag_name: 'label'),
+                     wd_element(tag_name: 'label'),
+                     wd_element(tag_name: 'label')]
+
+        allow(browser).to receive(:execute_script).and_return('foob', 'Foo', 'foo')
 
         labels = [element(watir_element: Watir::Label, wd: label_wds[0], for: '', input: inputs[0]),
                   element(watir_element: Watir::Label, wd: label_wds[1], for: '', input: inputs[1]),
@@ -57,7 +60,6 @@ describe Watir::Locators::Element::Matcher do
         expect(labels[1]).not_to receive(:for)
 
         allow(query_scope).to receive(:labels).and_return(labels)
-        allow(matcher).to receive(:deprecate_text_regexp).exactly(3).times
 
         values_to_match = {label_element: 'foo'}
 
@@ -71,14 +73,16 @@ describe Watir::Locators::Element::Matcher do
         inputs = [element(watir_element: Watir::Input, wd: wd_element(tag_name: 'input')),
                   element(watir_element: Watir::Input, wd: input_wds[1])]
 
-        label_wds = [wd_element(tag_name: 'label', text: 'foo'),
-                     wd_element(tag_name: 'label', text: 'foo')]
+        label_wds = [wd_element(tag_name: 'label'),
+                     wd_element(tag_name: 'label'),
+                     wd_element(tag_name: 'label')]
+
+        allow(browser).to receive(:execute_script).and_return('foo', 'foo')
 
         labels = [element(watir_element: Watir::Label, wd: label_wds[0], for: '', input: inputs[0]),
                   element(watir_element: Watir::Label, wd: label_wds[1], for: '', input: inputs[1])]
 
         allow(query_scope).to receive(:labels).and_return(labels)
-        allow(matcher).to receive(:deprecate_text_regexp).exactly(2).times
 
         values_to_match = {label_element: 'foo'}
 
@@ -89,14 +93,16 @@ describe Watir::Locators::Element::Matcher do
         input_wds = [wd_element(tag_name: 'input', attributes: {id: 'foo'}),
                      wd_element(tag_name: 'input', attributes: {id: 'bfoo'})]
 
-        label_wds = [wd_element(tag_name: 'label', text: 'Not this'),
-                     wd_element(tag_name: 'label', text: 'Or This')]
+        label_wds = [wd_element(tag_name: 'label'),
+                     wd_element(tag_name: 'label'),
+                     wd_element(tag_name: 'label')]
+
+        allow(browser).to receive(:execute_script).and_return('Not this', 'or this')
 
         labels = [element(watir_element: Watir::Label, wd: label_wds[0], for: 'foo'),
                   element(watir_element: Watir::Label, wd: label_wds[1], for: 'bfoo')]
 
         allow(query_scope).to receive(:labels).and_return(labels)
-        allow(matcher).to receive(:deprecate_text_regexp).exactly(2).times
 
         values_to_match = {label_element: 'foo'}
 
@@ -110,14 +116,15 @@ describe Watir::Locators::Element::Matcher do
         inputs = [element(watir_element: Watir::Input, wd: wd_element(tag_name: 'input')),
                   element(watir_element: Watir::Input, wd: wd_element(tag_name: 'input'))]
 
-        label_wds = [wd_element(tag_name: 'label', text: 'foob'),
-                     wd_element(tag_name: 'label', text: 'foo')]
+        label_wds = [wd_element(tag_name: 'label'),
+                     wd_element(tag_name: 'label')]
+
+        allow(browser).to receive(:execute_script).and_return('foob', 'foo')
 
         labels = [element(watir_element: Watir::Label, wd: label_wds[0], for: '', input: inputs[0]),
                   element(watir_element: Watir::Label, wd: label_wds[1], for: '', input: inputs[1])]
 
         allow(query_scope).to receive(:labels).and_return(labels)
-        allow(matcher).to receive(:deprecate_text_regexp).exactly(2).times
 
         values_to_match = {label_element: 'foo'}
 
@@ -191,11 +198,10 @@ describe Watir::Locators::Element::Matcher do
       end
 
       it 'by text' do
-        elements = [wd_element(text: 'foo'),
-                    wd_element(text: 'Foob')]
+        elements = [wd_element, wd_element]
         @values_to_match = {text: 'Foob'}
 
-        allow(matcher).to receive(:deprecate_text_regexp).exactly(3).times
+        allow(browser).to receive(:execute_script).and_return('foo', 'Foob')
 
         expect(matcher.match(elements, values_to_match, @filter)).to eq elements[1]
       end
@@ -290,12 +296,10 @@ describe Watir::Locators::Element::Matcher do
       end
 
       it 'by text' do
-        elements = [wd_element(text: 'foo'),
-                    wd_element(text: 'Foob'),
-                    wd_element(text: 'bBarb')]
+        elements = [wd_element, wd_element, wd_element]
         @values_to_match = {text: /Foo|Bar/}
 
-        allow(matcher).to receive(:deprecate_text_regexp).exactly(3).times
+        allow(browser).to receive(:execute_script).and_return('foo', 'Foob', 'bBarb')
 
         expect(matcher.match(elements, values_to_match, @filter)).to eq [elements[1], elements[2]]
       end
@@ -369,55 +373,42 @@ describe Watir::Locators::Element::Matcher do
     # See equivalent tests in checkbox_spec
     context 'text_regexp deprecations' do
       let(:filter) { :first }
-      let(:elements) do
-        [wd_element(text: 'all visible'),
-         wd_element(text: 'some visible')]
-      end
+      let(:elements) { [wd_element, wd_element] }
 
       it 'not thrown when still matched by text content' do
         @values_to_match = {text: /some visible/}
-        allow(browser).to receive(:execute_script).and_return('some visible some hidden')
-        allow(browser).to receive(:timer).and_return(Watir::Wait::Timer.new)
-        allow(browser).to receive(:timer=).and_return(Watir::Wait::Timer.new)
+        allow(browser).to receive(:execute_script).and_return('all visible', 'some visible')
 
-        expect {
-          expect(matcher.match(elements, values_to_match, filter)).to eq elements[1]
-        }.not_to have_deprecated_text_regexp
+        expect(matcher.match(elements, values_to_match, filter)).to eq elements[1]
       end
 
       it 'not thrown with complex regexp matched by text content' do
         @values_to_match = {text: /some (in|)visible/}
-        allow(browser).to receive(:execute_script).and_return('some visible some hidden')
-        allow(browser).to receive(:timer).and_return(Watir::Wait::Timer.new)
-        allow(browser).to receive(:timer=).and_return(Watir::Wait::Timer.new)
+        allow(browser).to receive(:execute_script).and_return('all visible', 'some visible')
 
-        expect {
-          expect(matcher.match(elements, values_to_match, filter)).to eq elements[1]
-        }.not_to have_deprecated_text_regexp
+        expect(matcher.match(elements, values_to_match, filter)).to eq elements[1]
       end
 
       it 'thrown when no longer matched by text content' do
         @values_to_match = {text: /some visible$/}
-        allow(browser).to receive(:execute_script).and_return('some visible some hidden')
+        allow(browser).to receive(:execute_script).and_return('all visible', 'some visible')
         allow(browser).to receive(:timer).and_return(Watir::Wait::Timer.new)
         allow(browser).to receive(:timer=).and_return(Watir::Wait::Timer.new)
 
-        expect {
-          expect(matcher.match(elements, values_to_match, filter)).to eq elements[1]
-        }.to have_deprecated_text_regexp
+        expect(matcher.match(elements, values_to_match, filter)).to eq elements[1]
       end
 
       it 'not thrown when element does not exist' do
         @values_to_match = {text: /definitely not there/}
+        allow(browser).to receive(:execute_script).and_return('all visible', 'some visible')
 
-        expect {
-          expect(matcher.match(elements, values_to_match, filter)).to eq elements[1]
-        }.to_not have_deprecated_text_regexp
+        expect(matcher.match(elements, values_to_match, filter)).to eq nil
       end
 
       # Note: This will work after:text_regexp deprecation removed
       it 'keeps element from being located' do
         @values_to_match = {text: /some visible some hidden/}
+        allow(browser).to receive(:execute_script).and_return('all visible', 'some visible')
 
         expect(matcher.match(elements, values_to_match, filter)).to be_nil
       end

data/spec/unit/match_elements/text_field_spec.rb

@@ -44,25 +44,25 @@ describe Watir::Locators::TextField::Matcher do
 
     context 'when label element' do
       it 'converts value to text' do
-        elements = [wd_element(tag_name: 'label', text: 'foo'),
-                    wd_element(tag_name: 'label', text: 'Foob')]
+        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)
-        allow(matcher).to receive(:deprecate_text_regexp).exactly(2).times
 
         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', text: 'foo'),
-                    wd_element(tag_name: 'label', text: 'Foob')]
+        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)
-        allow(matcher).to receive(:deprecate_text_regexp).exactly(2).times
 
         expect(matcher.match(elements, values_to_match, :all)).to eq [elements[1]]
       end

data/spec/unit/selector_builder/element_spec.rb

@@ -95,15 +95,6 @@ describe Watir::Locators::Element::SelectorBuilder do
         expect(selector_builder.build(selector)).to eq built
       end
 
-      it 'values with spaces' do
-        selector = {class_name: 'multiple classes here'}
-        built = {xpath: ".//*[contains(concat(' ', @class, ' '), ' multiple classes here ')]"}
-
-        expect {
-          expect(selector_builder.build(selector)).to eq built
-        }.to have_deprecated_class_array
-      end
-
       it 'single String concatenates' do
         selector = {class: 'user'}
         built = {xpath: ".//*[contains(concat(' ', @class, ' '), ' user ')]"}
@@ -281,13 +272,11 @@ describe Watir::Locators::Element::SelectorBuilder do
         expect(selector_builder.build(selector)).to eq built
       end
 
-      it 'with caption attribute' do
-        selector = {caption: 'Add user'}
-        built = {xpath: ".//*[normalize-space()='Add user']"}
+      it 'Regexp uses contains normalize space' do
+        selector = {text: /Add/}
+        built = {xpath: ".//*[contains(normalize-space(), 'Add')]"}
 
-        expect {
-          expect(selector_builder.build(selector)).to eq built
-        }.to have_deprecated_caption
+        expect(selector_builder.build(selector)).to eq built
       end
 
       it 'raises exception when text is not a String or Regexp' do
@@ -346,7 +335,8 @@ describe Watir::Locators::Element::SelectorBuilder do
 
       it 'returns a label_element if complex' do
         selector = {label: /Ca|rs/}
-        built = {xpath: './/*', label_element: /Ca|rs/}
+        xpath = './/*[@id=//label[normalize-space()]/@for or parent::label[normalize-space()]]'
+        built = {xpath: xpath, label_element: /Ca|rs/}
 
         expect(selector_builder.build(selector)).to eq built
       end
@@ -628,13 +618,6 @@ describe Watir::Locators::Element::SelectorBuilder do
         expect(selector_builder.build(selector)).to eq built
       end
 
-      it 'text with any Regexp' do
-        selector = {text: /Add/}
-        built = {xpath: './/*', text: /Add/}
-
-        expect(selector_builder.build(selector)).to eq built
-      end
-
       it 'visible' do
         selector = {tag_name: 'div', visible: true}
         built = {xpath: ".//*[local-name()='div']", visible: true}

data/spec/unit/selector_builder/text_field_spec.rb

@@ -156,21 +156,20 @@ describe Watir::Locators::TextField::SelectorBuilder do
         expect(selector_builder.build(selector)).to eq built
       end
 
-      # TODO: Can use contains once remove :text_regexp deprecation
-      xit 'using simple Regexp' do
+      it 'using simple Regexp' do
         selector = {label: /First/}
         built = {xpath: ".//*[local-name()='input'][not(@type) or (#{negative_types})]" \
-"[@id=//label[contains(text(), 'First')]/@for or parent::label[contains(text(), 'First')]]"}
+"[@id=//label[contains(normalize-space(), 'First')]/@for or parent::label[contains(normalize-space(), 'First')]]"}
 
         expect(selector_builder.build(selector)).to eq built
       end
 
-      # TODO: Can use contains once remove :text_regexp deprecation
-      xit 'using complex Regexp' do
+      it 'using complex Regexp' do
         selector = {label: /([qa])st? name/}
         built = {xpath: ".//*[local-name()='input'][not(@type) or (#{negative_types})]" \
-"[@id=//label[contains(text(), 's') and contains(text(), ' name')]/@for or " \
-"parent::label[contains(text(), 's') and contains(text(), ' name')]]", label_element: /([qa])st? name/}
+"[@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

data/spec/watirspec/alert_spec.rb

@@ -9,12 +9,10 @@ describe 'Alert API' do
     browser.alert.ok if browser.alert.exists?
   end
 
-  compliant_on :relaxed_locate do
-    context 'Relaxed Waits' do
-      context 'when acting on an alert' do
-        it 'raises exception after timing out' do
-          expect { browser.alert.text }.to wait_and_raise_unknown_object_exception
-        end
+  context 'Waits' do
+    context 'when acting on an alert' do
+      it 'raises exception after timing out' do
+        expect { browser.alert.text }.to wait_and_raise_unknown_object_exception
       end
     end
   end
@@ -53,21 +51,6 @@ describe 'Alert API' do
         expect(browser.alert).to_not exist
       end
     end
-
-    not_compliant_on :relaxed_locate do
-      describe 'wait_until_present' do
-        it 'waits until alert is present and goes on' do
-          browser.button(id: 'timeout-alert').click
-          browser.alert.wait_until_present.ok
-
-          expect(browser.alert).to_not exist
-        end
-
-        it 'raises error if alert is not present after timeout' do
-          expect { browser.alert.wait_until_present.ok }.to raise_timeout_exception
-        end
-      end
-    end
   end
 
   context 'confirm' do

data/spec/watirspec/browser_spec.rb

@@ -75,7 +75,7 @@ describe 'Browser' do
   bug 'Capitalization issue', :safari do
     describe '#name' do
       it 'returns browser name' do
-        expect(browser.name).to eq(WatirSpec.implementation.browser_args.first)
+        expect(browser.name).to eq(WatirSpec.implementation.browser_name)
       end
     end
   end
@@ -519,7 +519,7 @@ describe 'Browser' do
       browser.close
       @opts = WatirSpec.implementation.browser_args.last
 
-      @opts[:page_load_strategy] = 'none'
+      @opts[:options] = {page_load_strategy: :none}
       browser = WatirSpec.new_browser
 
       start_time = Time.now

data/spec/watirspec/cookies_spec.rb

@@ -93,7 +93,7 @@ describe 'Browser#cookies' do
     expect((cookie[:expires]).to_i).to be_within(2).of(expires.to_i)
   end
 
-  bug 'https://bugs.chromium.org/p/chromedriver/issues/detail?id=2727', :chrome, :safari do
+  bug 'https://bugs.chromium.org/p/chromedriver/issues/detail?id=2727', :chrome, :safari, :edge do
     it 'adds a cookie with security' do
       browser.goto set_cookie_url
 

data/spec/watirspec/elements/button_spec.rb

@@ -41,16 +41,6 @@ describe 'Button' do
       expect(browser.button(value: /Button 4 With Child Text/)).to exist
     end
 
-    it 'returns true if the button exists (how = :caption)' do
-      expect {
-        expect(browser.button(caption: 'Button 2')).to exist
-      }.to have_deprecated_caption
-
-      expect {
-        expect(browser.button(caption: /Button 2/)).to exist
-      }.to have_deprecated_caption
-    end
-
     it 'returns the first button if given no args' do
       expect(browser.button).to exist
     end

data/spec/watirspec/elements/checkbox_spec.rb

@@ -26,29 +26,17 @@ describe 'CheckBox' do
       expect(browser.checkbox(xpath: "//input[@id='new_user_interests_books']")).to exist
     end
 
-    not_compliant_on :watigiri do
-      it 'handles text_regexp deprecations for label locators' do
-        expect {
-          expect(browser.checkbox(label: /some visible/)).to exist
-        }.to_not have_deprecated_text_regexp
-
-        expect {
-          expect(browser.checkbox(label: /some (visible|Jeff)/)).to exist
-        }.to_not have_deprecated_text_regexp
-
-        expect {
-          expect(browser.checkbox(label: /this will not match/)).to exist
-        }.to_not have_deprecated_text_regexp
-      end
-
-      bug 'Safari is not filtering out hidden text', :safari do
-        it 'handles text_regexp deprecation in spite of hidden text' do
-          expect(browser.checkbox(label: /some visible some hidden/)).to_not exist
+    # TODO: More of this for text & labels somewhere central
+    it 'handles text_regexp deprecations for label locators' do
+      expect(browser.checkbox(label: /some visible/)).to exist
+      expect(browser.checkbox(label: /some (visible|Jeff)/)).to exist
+      expect(browser.checkbox(label: /none visible/)).to exist
+      expect(browser.checkbox(label: /this will not match/)).to_not exist
+    end
 
-          expect {
-            expect(browser.checkbox(label: /some visible$/)).to exist
-          }.to have_deprecated_text_regexp
-        end
+    bug 'Safari is not filtering out hidden text', :safari do
+      it 'handles text_regexp deprecation in spite of hidden text' do
+        expect(browser.checkbox(label: /some visible some hidden/)).to exist
       end
     end