watir 6.3.0 → 6.4.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d3a0cb0525118548da109542afb75980a1d42cf
-  data.tar.gz: 0bc02ea05b55da8b92650cecfd3a3a3fe98ab39b
+  metadata.gz: 9b67d137fb553725a3560f0a319874cc5306ccb4
+  data.tar.gz: 94a5b69d2a27b360ba506e974553fec6f5b7dcf8
 SHA512:
-  metadata.gz: 03f724ca3a53ec63b963d76bc6f36f727003d52b484032ac3790f1962ad2b5a8f5e90e9864a18cd644fd51451030715a13d0d3805077749e79fce4f00d48b6cc
-  data.tar.gz: 66cf35ca15c505bc84dec52bc9b42303c7ba6c3473703a8edc91ea80882f1e48d6ff8d17de888ee5dcab3633dd0e7573de46d81bdafd7bba923fa851fc44a045
+  metadata.gz: 57eff53b2276128e6b44b27c840159aabe135e24b0fb76d255ab67d656de25e525ff90f1a9ff99ae8059410870fd424ddb53db3dab41495f177246d8f1410590
+  data.tar.gz: '08692e0b7d43a2b9aa9092ce1a2009f72d1bce025bf5f8918a6d7167353c08c9a23808230179694267d62c94962c5bfb97d0d45bebf8e1f2cd75a04d21f4b489'

data/CHANGES.md

@@ -1,3 +1,7 @@
+### 6.4.0.rc1 (2017-06-21)
+
+* Significant performance updates
+
 ### 6.3.0 (2017-06-20)
 
 * Allow locating elements by attribute presence/absence (#345)

data/lib/watir/browser.rb

@@ -9,6 +9,7 @@ module Watir
     include HasWindow
     include Waitable
 
+    attr_writer :default_context
     attr_reader :driver
     attr_reader :after_hooks
     alias_method :wd, :driver # ensures duck typing with Watir::Element
@@ -51,8 +52,8 @@ module Watir
       end
 
       @after_hooks = AfterHooks.new(self)
-      @current_frame  = nil
       @closed = false
+      @default_context = true
     end
 
     def inspect
@@ -292,10 +293,7 @@ module Watir
     #
 
     def exist?
-      assert_exists
-      true
-    rescue Exception::NoMatchingWindowFoundException, Exception::Error
-      false
+      !@closed && window.present?
     end
     alias_method :exists?, :exist?
 
@@ -306,17 +304,16 @@ module Watir
     #
 
     def assert_exists
-      if @closed
-        raise Exception::Error, "browser was closed"
-      elsif !window.present?
-        raise Exception::NoMatchingWindowFoundException, "browser window was closed"
-      else
-        driver.switch_to.default_content
-        true
-      end
+      ensure_context
+      return if window.present?
+      raise Exception::NoMatchingWindowFoundException, "browser window was closed"
+    end
+
+    def ensure_context
+      raise Exception::Error, "browser was closed" if @closed
+      driver.switch_to.default_content unless @default_context
+      @default_context = true
     end
-    alias_method :wait_for_exists, :assert_exists
-    alias_method :wait_for_present, :assert_exists
 
     def browser
       self

data/lib/watir/element_collection.rb

@@ -114,7 +114,7 @@ module Watir
     private
 
     def elements
-      @query_scope.is_a?(IFrame) ? @query_scope.switch_to! : @query_scope.send(:assert_exists)
+      @query_scope.send :ensure_context
 
       element_validator = element_validator_class.new
       selector_builder = selector_builder_class.new(@query_scope, @selector, element_class.attribute_list)

data/lib/watir/elements/element.rb

@@ -364,7 +364,8 @@ module Watir
     #
 
     def wd
-      assert_exists
+      return driver if @element.is_a? FramedDriver
+      assert_exists if @element.nil?
       @element
     end
 
@@ -439,17 +440,17 @@ module Watir
 
       if tag_name == "input"
         klass = case elem.attribute(:type)
-          when *Button::VALID_TYPES
-            Button
-          when 'checkbox'
-            CheckBox
-          when 'radio'
-            Radio
-          when 'file'
-            FileField
-          else
-            TextField
-          end
+                when *Button::VALID_TYPES
+                  Button
+                when 'checkbox'
+                  CheckBox
+                when 'radio'
+                  Radio
+                when 'file'
+                  FileField
+                else
+                  TextField
+                end
       else
         klass = Watir.element_class_for(tag_name)
       end
@@ -500,42 +501,30 @@ module Watir
       return if exists? # Performance shortcut
 
       begin
-        @query_scope.wait_for_exists
+        @query_scope.wait_for_exists unless @query_scope.is_a? Browser
         wait_until(&:exists?)
       rescue Watir::Wait::TimeoutError
-        unless Watir.default_timeout == 0
-          message = "This code has slept for the duration of the default timeout "
-          message << "waiting for an Element to exist. If the test is still passing, "
-          message << "consider using Element#exists? instead of rescuing UnknownObjectException"
-          warn message
-        end
-        raise unknown_exception, "timed out after #{Watir.default_timeout} seconds, "\
-                                         "waiting for #{inspect} to be located"
+        msg = "timed out after #{Watir.default_timeout} seconds, waiting for #{inspect} to be located"
+        raise unknown_exception, msg
       end
     end
 
     def wait_for_present
-      return assert_exists unless Watir.relaxed_locate?
+      return visible? unless Watir.relaxed_locate?
+      return if present?
 
-      wait_for_exists
       begin
         @query_scope.wait_for_present
         wait_until_present
-      rescue Watir::Wait::TimeoutError => ex
-        unless Watir.default_timeout == 0
-          message = "This code has slept for the duration of the default timeout "
-          message << "waiting for an Element to be present. If the test is still passing, "
-          message << "consider using Element#exists? instead of rescuing UnknownObjectException"
-          warn message
-        end
-        raise unknown_exception, "element located, but #{ex.message}"
+      rescue Watir::Wait::TimeoutError
+        msg = "element located, but timed out after #{Watir.default_timeout} seconds, waiting for #{inspect} to be present"
+        raise unknown_exception, msg
       end
     end
 
     def wait_for_enabled
       return assert_enabled unless Watir.relaxed_locate?
 
-      wait_for_present
       begin
         wait_until(&:enabled?)
       rescue Watir::Wait::TimeoutError
@@ -545,9 +534,12 @@ module Watir
     end
 
     def wait_for_writable
-      return assert_writable unless Watir.relaxed_locate?
-
+      wait_for_exists
       wait_for_enabled
+      unless Watir.relaxed_locate?
+        raise_writable unless !respond_to?(:readonly?) || !readonly?
+      end
+
       begin
         wait_until { !respond_to?(:readonly?) || !readonly? }
       rescue Watir::Wait::TimeoutError
@@ -559,7 +551,7 @@ module Watir
     # Ensure that the element exists, making sure that it is not stale and located if necessary
     def assert_exists
       if @element && @selector.empty?
-        ensure_context
+        @query_scope.ensure_context
         reset! if stale?
       elsif @element && !stale?
         return
@@ -577,13 +569,13 @@ module Watir
     end
 
     def locate
-      ensure_context
+      @query_scope.ensure_context
 
       element_validator = element_validator_class.new
       selector_builder = selector_builder_class.new(@query_scope, @selector, self.class.attribute_list)
       locator = locator_class.new(@query_scope, @selector, selector_builder, element_validator)
 
-      locator.locate
+      @element = locator.locate
     end
 
     def selector_string
@@ -591,12 +583,31 @@ module Watir
       "#{@query_scope.selector_string} --> #{@selector.inspect}"
     end
 
+    # Ensure the driver is in the desired browser context
+    def ensure_context
+      assert_exists
+    end
+
     private
 
     def unknown_exception
       Watir::Exception::UnknownObjectException
     end
 
+    def raise_writable
+      message = "element present and enabled, but timed out after #{Watir.default_timeout} seconds, waiting for #{inspect} to not be readonly"
+      raise ObjectReadOnlyException, message
+    end
+
+    def raise_disabled
+      message = "element present and enabled, but timed out after #{Watir.default_timeout} seconds, waiting for #{inspect} to not be disabled"
+      raise ObjectDisabledException, message
+    end
+
+    def raise_present
+      raise unknown_exception, "element located, but timed out after #{Watir.default_timeout} seconds, waiting for #{inspect} to be present"
+    end
+
     def locator_class
       Kernel.const_get("#{Watir.locator_namespace}::#{element_class_name}::Locator")
     rescue NameError
@@ -619,11 +630,6 @@ module Watir
       self.class.name.split('::').last
     end
 
-    # Ensure the driver is in the desired browser context
-    def ensure_context
-      @query_scope.is_a?(IFrame) ? @query_scope.switch_to! : @query_scope.assert_exists
-    end
-
     def attribute?(attribute_name)
       !attribute_value(attribute_name).nil?
     end
@@ -634,14 +640,6 @@ module Watir
       end
     end
 
-    def assert_writable
-      assert_enabled
-
-      if respond_to?(:readonly?) && readonly?
-        raise ObjectReadOnlyException, "object is read only #{inspect}"
-      end
-    end
-
     def assert_is_element(obj)
       unless obj.kind_of? Watir::Element
         raise TypeError, "execpted Watir::Element, got #{obj.inspect}:#{obj.class}"
@@ -652,10 +650,30 @@ module Watir
       already_locked = Wait.timer.locked?
       Wait.timer = Wait::Timer.new(timeout: Watir.default_timeout) unless already_locked
       begin
-        send exist_check
+        if exist_check == :wait_for_enabled
+          if self.is_a?(Input) || self.is_a?(Button) || self.is_a?(Select) || self.is_a?(Option)
+            wait_for_enabled
+          else
+            wait_for_exists
+          end
+        else
+          send(exist_check)
+        end
+
         yield
       rescue Selenium::WebDriver::Error::StaleElementReferenceError
         retry
+      rescue Selenium::WebDriver::Error::ElementNotVisibleError, Selenium::WebDriver::Error::ElementNotInteractableError
+        raise_present unless Wait.timer.remaining_time > 0
+        raise_present unless exist_check == :wait_for_present || exist_check == :wait_for_enabled
+        retry
+      rescue Selenium::WebDriver::Error::InvalidElementStateError => ex
+        raise_disabled unless Wait.timer.remaining_time > 0
+        raise_disabled unless exist_check == :wait_for_writable || exist_check == :wait_for_enabled
+        raise_disabled unless ex.message.include?('user-editable')
+        retry
+      rescue Selenium::WebDriver::Error::NoSuchWindowError
+        raise Exception::NoMatchingWindowFoundException, "browser window was closed"
       ensure
         Wait.timer.reset! unless already_locked
       end

data/lib/watir/elements/iframe.rb

@@ -3,7 +3,7 @@ module Watir
 
     def locate
       return if @selector.empty?
-      @query_scope.assert_exists
+      @query_scope.ensure_context
 
       selector = @selector.merge(tag_name: frame_tag)
       element_validator = element_validator_class.new
@@ -13,7 +13,7 @@ module Watir
       element = locator.locate
       element or raise unknown_exception, "unable to locate #{@selector[:tag_name]} using #{selector_string}"
 
-      FramedDriver.new(element, driver)
+      @element = FramedDriver.new(element, browser)
     end
 
     def ==(other)
@@ -51,7 +51,7 @@ module Watir
 
     def html
       wait_for_exists
-      wd.page_source
+      @element.page_source
     end
 
     #
@@ -67,6 +67,10 @@ module Watir
       browser.send :wrap_elements_in, self, returned
     end
 
+    def ensure_context
+      switch_to!
+    end
+
     private
 
     def frame_tag
@@ -118,9 +122,10 @@ module Watir
   #
 
   class FramedDriver
-    def initialize(element, driver)
+    def initialize(element, browser)
       @element = element
-      @driver = driver
+      @browser = browser
+      @driver = browser.driver
     end
 
     def ==(other)
@@ -152,6 +157,7 @@ module Watir
 
     def switch!
       @driver.switch_to.frame @element
+      @browser.default_context = false
     rescue Selenium::WebDriver::Error::NoSuchFrameError => e
       raise Exception::UnknownFrameException, e.message
     end

data/lib/watir/locators/element/locator.rb

@@ -44,10 +44,8 @@ module Watir
                       find_first_by_multiple
                     end
 
-          # This actually only applies when finding by xpath/css - browser.text_field(:xpath, "//input[@type='radio']")
-          # We don't need to validate the element if we built the xpath ourselves.
-          # It is also used to alter behavior of methods locating more than one type of element
-          # (e.g. text_field locates both input and textarea)
+          # Validation not necessary if Watir builds the xpath
+          return element unless @selector.key?(:xpath) || @selector.key?(:css)
           element_validator.validate(element, @selector) if element
         rescue Selenium::WebDriver::Error::NoSuchElementError, Selenium::WebDriver::Error::StaleElementReferenceError
           nil

data/lib/watir/locators/element/validator.rb

@@ -10,11 +10,6 @@ module Watir
             return unless selector_tag_name === element_tag_name
           end
 
-          if element_tag_name == 'input'
-            # TODO - Verify this is desired behavior based on https://bugzilla.mozilla.org/show_bug.cgi?id=1290963
-            return if selector[:type] && selector[:type] != element.attribute(:type).downcase
-          end
-
           element
         end
       end

data/lib/watir/wait/timer.rb

@@ -2,8 +2,11 @@ module Watir
   module Wait
     class Timer
 
+      attr_reader :remaining_time
+
       def initialize(timeout: nil)
         @end_time = current_time + timeout if timeout
+        @remaining_time = @end_time - current_time if @end_time
       end
 
       #
@@ -17,7 +20,8 @@ module Watir
         end_time = @end_time || current_time + timeout
         loop do
           yield(block)
-          break if current_time > end_time
+          @remaining_time = end_time - current_time
+          break if @remaining_time < 0
         end
       end
 

data/spec/watirspec/alert_spec.rb

@@ -57,9 +57,14 @@ describe 'Alert API' do
           end
 
           it 'raises error if alert is not present after timeout' do
-            expect {
-              browser.alert.wait_until_present.ok
-            }.to raise_error(Watir::Wait::TimeoutError)
+            begin
+              Watir.default_timeout = 2
+              expect {
+                browser.alert.wait_until_present.ok
+              }.to raise_error(Watir::Wait::TimeoutError)
+            ensure
+              Watir.default_timeout = 30
+            end
           end
         end
       end

data/spec/watirspec/elements/button_spec.rb

@@ -226,6 +226,10 @@ describe "Button" do
     it "raises UnknownObjectException if the button doesn't exist" do
       expect { browser.button(name: "no_such_name").enabled? }.to raise_unknown_object_exception
     end
+
+    it "raises ObjectDisabledException if disabled button is clicked" do
+      expect { browser.button(name: "new_user_submit_disabled").click }.to raise_object_disabled_exception
+    end
   end
 
   describe "#disabled?" do

data/spec/watirspec/elements/text_field_spec.rb

@@ -197,6 +197,10 @@ describe "TextField" do
     it "raises UnknownObjectException if the text field doesn't exist" do
       expect { browser.text_field(id: 'no_such_id').readonly? }.to raise_unknown_object_exception
     end
+
+    it "raises UnknownReadOnlyException if sending keys to readonly element" do
+      expect { browser.text_field(id: 'new_user_code').set 'foo' }.to raise_object_read_only_exception
+    end
   end
 
   # Manipulation methods

data/spec/watirspec/relaxed_locate_spec.rb

@@ -50,108 +50,6 @@ describe 'Watir#relaxed_locate?' do
         end
       end
 
-      context 'when evaluating order of failure precedence' do
-        it 'fails first for parent not existing' do
-          begin
-            Watir.default_timeout = 0
-            inspected = '#<Watir::Div: located: false; {:id=>"no_parent", :tag_name=>"div"}>'
-            element = browser.div(id: 'no_parent').div(id: 'no_child')
-            error = Watir::Exception::UnknownObjectException
-            message = "timed out after #{Watir.default_timeout} seconds, waiting for #{inspected} to be located"
-            expect { element.click }.to raise_exception(error, message)
-          ensure
-            Watir.default_timeout = 30
-          end
-        end
-
-        it 'fails for child not existing if parent exists' do
-          begin
-            Watir.default_timeout = 0
-            inspected = '#<Watir::Div: located: false; {:id=>"buttons", :tag_name=>"div"} --> {:id=>"no_child", :tag_name=>"div"}>'
-            element = browser.div(id: 'buttons').div(id: 'no_child')
-            error = Watir::Exception::UnknownObjectException
-            message = "timed out after #{Watir.default_timeout} seconds, waiting for #{inspected} to be located"
-            expect { element.click }.to raise_exception(error, message)
-          ensure
-            Watir.default_timeout = 30
-          end
-        end
-
-        it 'fails for parent not present if child exists' do
-          begin
-            Watir.default_timeout = 0.5
-            inspected = '#<Watir::Div: located: true; {:id=>"also_hidden", :tag_name=>"div"}>'
-            element = browser.div(id: 'also_hidden').div(id: 'hidden_child')
-            error = Watir::Exception::UnknownObjectException
-            message = "element located, but timed out after #{Watir.default_timeout} seconds, waiting for true condition on #{inspected}"
-            allow($stderr).to receive(:write).twice
-            expect { element.click }.to raise_exception(error, message)
-          ensure
-            Watir.default_timeout = 30
-          end
-        end
-
-        it 'fails for child not present if parent is present' do
-          begin
-            Watir.default_timeout = 0.5
-            inspected = '#<Watir::Button: located: true; {:id=>"buttons", :tag_name=>"div"} --> {:id=>"btn2", :tag_name=>"button"}>'
-            element = browser.div(id: 'buttons').button(id: 'btn2')
-            error = Watir::Exception::UnknownObjectException
-            message = "element located, but timed out after #{Watir.default_timeout} seconds, waiting for true condition on #{inspected}"
-            allow($stderr).to receive(:write).twice
-            expect { element.click }.to raise_exception(error, message)
-          ensure
-            Watir.default_timeout = 30
-          end
-        end
-
-        it 'fails for element not enabled if present' do
-          browser.goto(WatirSpec.url_for("forms_with_input_elements.html"))
-          begin
-            Watir.default_timeout = 0.5
-            inspected = '#<Watir::TextField: located: true; {:id=>"new_user", :tag_name=>"form"} --> {:id=>"good_luck", :tag_name=>"input or textarea", :type=>"(any text type)"}>'
-            element = browser.form(id: 'new_user').text_field(id: 'good_luck')
-            error = Watir::Exception::ObjectDisabledException
-            message = "element present, but timed out after #{Watir.default_timeout} seconds, waiting for #{inspected} to be enabled"
-            expect { element.set('foo') }.to raise_exception(error, message)
-          ensure
-            Watir.default_timeout = 30
-          end
-        end
-
-        it 'fails for element being readonly if enabled' do
-          browser.goto(WatirSpec.url_for("forms_with_input_elements.html"))
-          begin
-            Watir.default_timeout = 0.5
-            inspected = '#<Watir::TextField: located: true; {:id=>"new_user", :tag_name=>"form"} --> {:id=>"new_user_code", :tag_name=>"input or textarea", :type=>"(any text type)"}>'
-            element = browser.form(id: 'new_user').text_field(id: 'new_user_code')
-            error = Watir::Exception::ObjectReadOnlyException
-            message = "element present and enabled, but timed out after #{Watir.default_timeout} seconds, waiting for #{inspected} to not be readonly"
-            expect { element.set('foo') }.to raise_exception(error, message)
-          ensure
-            Watir.default_timeout = 30
-          end
-        end
-      end
-
-      it 'gives warning when rescuing for flow control' do
-        begin
-          Watir.default_timeout = 1
-          element = browser.link(id: 'not_there')
-          message = "This code has slept for the duration of the default timeout "
-          message << "waiting for an Element to exist. If the test is still passing, "
-          message << "consider using Element#exists? instead of rescuing UnknownObjectException\n"
-          expect do
-            begin
-              element.click
-            rescue Watir::Exception::UnknownObjectException
-            end
-          end.to output(message).to_stderr
-        ensure
-          Watir.default_timeout = 30
-        end
-      end
-
       it 'ensures all checks happen once even if time has expired' do
         begin
           Watir.default_timeout = -1
@@ -160,19 +58,6 @@ describe 'Watir#relaxed_locate?' do
           Watir.default_timeout = 30
         end
       end
-
-      it 'ensures that the same timeout is used for all of the calls' do
-        begin
-          Watir.default_timeout = 1.1
-          browser.a(id: 'add_foobar').click
-          allow($stderr).to receive(:write).twice
-          # Element created after 1 second, and displays after 2 seconds
-          # Click will only raise this exception if the timer is not reset between #wait_for_exists and #wait_for_present
-          expect { browser.div(id: 'foobar').click }.to raise_exception Watir::Exception::UnknownObjectException
-        ensure
-          Watir.default_timeout = 30
-        end
-      end
     end
   end
 
@@ -202,12 +87,7 @@ describe 'Watir#relaxed_locate?' do
           start_time = ::Time.now
           browser.a(id: 'show_bar').click
 
-          compliant_on :firefox do
-            expect { browser.div(id: 'bar').click }.to raise_exception(Selenium::WebDriver::Error::ElementNotInteractableError)
-          end
-          not_compliant_on :firefox do
-            expect { browser.div(id: 'bar').click }.to raise_exception(Selenium::WebDriver::Error::ElementNotVisibleError)
-          end
+          expect { browser.div(id: 'bar').click }.to raise_unknown_object_exception
 
           expect(::Time.now - start_time).to be < 1
         end

data/spec/watirspec/wait_spec.rb

@@ -239,7 +239,7 @@ not_compliant_on :safari do
     describe "#wait_while_present" do
       it "waits until the element disappears" do
         browser.a(id: 'hide_foo').click
-        expect { browser.div(id: 'foo').wait_while_present(timeout: 1) }.to_not raise_exception
+        expect { browser.div(id: 'foo').wait_while_present(timeout: 2) }.to_not raise_exception
       end
 
       it "times out if the element doesn't disappear" do

data/watir.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'watir'
-  s.version     = '6.3.0'
+  s.version     = '6.4.0.rc1'
   s.platform    = Gem::Platform::RUBY
   s.authors     = ['Alex Rodionov', 'Titus Fortner']
   s.email       = ['p0deje@gmail.com', 'titusfortner@gmail.com']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: watir
 version: !ruby/object:Gem::Version
-  version: 6.3.0
+  version: 6.4.0.rc1
 platform: ruby
 authors:
 - Alex Rodionov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-20 00:00:00.000000000 Z
+date: 2017-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: selenium-webdriver
@@ -476,9 +476,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: watir
 rubygems_version: 2.5.2