ae_page_objects 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 545addc7d4b910134d2bbb7a29b6ec990cc190e5
-  data.tar.gz: 747b5268236901cc5cdf3bfadfa50ff2e9b6cd80
+  metadata.gz: 79847ab6fa6a51c16ec5127b80cc6e42035abfde
+  data.tar.gz: d20bbebe4ef811ccf92b75e15a3231957fd37fe1
 SHA512:
-  metadata.gz: ccff7683bc850c05d0e5f055fa39e92f4bee5f489e43cd1a01a97a90a931802ea493c5f9baa666bf89728f4c0f0a8e35ee281cd8eca869f7482cff47195ba289
-  data.tar.gz: eafb28c8a5e4ef4e3e450c4dc624064fcf1ecfee5ee7903dedade84853d71155c34687051ee08ecbb5027894c987e244fa102ec89368e9997bd95d5c2fcf7cd4
+  metadata.gz: 38aa636f72ece06a5c8722085e898736bc57db7b362c2f54752ec9878a585d8e9d10e6dddd090457ce0778e0909704a33b3e3daa654070345a13092845aa5feb
+  data.tar.gz: e75ab259fc8c46c28c1416622af05f6e65081e4f647e9a481c41463c30ae27a9c0267cc834c4e45212aa75b6eaceee5c40cdaaaaed7518ec1bb29d2ba35f013e

data/lib/ae_page_objects.rb

@@ -3,7 +3,7 @@ require 'capybara/dsl'
 
 require 'ae_page_objects/version'
 require 'ae_page_objects/exceptions'
-require 'ae_page_objects/util/page_polling'
+require 'ae_page_objects/util/wait_time_manager'
 
 module AePageObjects
   autoload :Node,              'ae_page_objects/node'
@@ -16,8 +16,6 @@ module AePageObjects
   autoload :Checkbox,          'ae_page_objects/elements/checkbox'
 
   class << self
-    include PagePolling
-
     attr_accessor :default_router
 
     def browser
@@ -35,22 +33,69 @@ module AePageObjects
       end
     end
 
-    def wait_until(seconds_to_wait = nil, error_message = nil)
-      seconds_to_wait ||= default_max_wait_time
-      start_time      = Time.now
+    def wait_until(seconds_to_wait = nil, error_message = nil, &block)
+      @wait_until ||= 0
+      @wait_until += 1
 
-      until result = yield
-        delay = seconds_to_wait - (Time.now - start_time)
+      result = nil
 
-        if delay <= 0
-          raise WaitTimeoutError, error_message || "Timed out waiting for condition"
-        end
+      if @wait_until > 1
+        # We want to ensure that only the top-level wait_until does the waiting error handling,
+        # which allows correct timing and best chance of recovering from an error.
+        result = call_wait_until_block(error_message, &block)
+      else
+        seconds_to_wait ||= default_max_wait_time
+        start_time      = Time.now
+
+        # In an effort to avoid flakiness, Capybara waits, rescues errors, reloads nodes, and
+        # retries.
+        #
+        # There are cases when Capybara will rescue an error and either nodes are not
+        # reloadable or the DOM has changed in a such a way that no amount of reloading will
+        # help (but perhaps a retry at the higher level may have a chance of success). This leads
+        # to us needless waiting for a long time just to fail.
+        #
+        # There are also cases when Selenium will take such a long time to respond with an error
+        # that Capybara's timeout will be exceeded and no reloading / retrying will occur. Instead,
+        # Capabara will just raise the error.
+        #
+        # In order to combat the two cases, we start with a lower Capybara wait time and increase
+        # it each iteration. This logic is encapsulated in a little utility class.
+        time_manager = WaitTimeManager.new(1.0, seconds_to_wait)
+        begin
+          result = time_manager.using_wait_time { call_wait_until_block(error_message, &block) }
+        rescue => e
+          errors = Capybara.current_session.driver.invalid_element_errors
+          errors += [Capybara::ElementNotFound]
+          errors += [DocumentLoadError, LoadingElementFailed, LoadingPageFailed]
+          errors += [WaitTimeoutError]
+          raise e unless errors.include?(e.class)
+
+          delay = seconds_to_wait - (Time.now - start_time)
+
+          if delay <= 0
+            # Raising the WaitTimeoutError in the rescue block ensures that Ruby attaches
+            # the original exception as the cause for our WaitTimeoutError.
+            raise WaitTimeoutError, e.message
+          end
 
-        sleep(0.05)
-        raise FrozenInTime, "Time appears to be frozen" if Time.now == start_time
+          sleep(0.05)
+          raise FrozenInTime, "Time appears to be frozen" if Time.now == start_time
+
+          retry
+        end
       end
 
       result
+    ensure
+      @wait_until -= 1
+    end
+
+    private
+
+    def call_wait_until_block(error_message, &block)
+      result = block.call
+      result ? result : raise(WaitTimeoutError, error_message || "Timed out waiting for condition")
     end
 
     def default_max_wait_time

data/lib/ae_page_objects/core/dsl.rb

@@ -6,13 +6,21 @@ module AePageObjects
     include InternalHelpers
 
     def inherited(subclass)
-      subclass.class_eval do
-        class << self
-          def element_attributes
-            @element_attributes ||= {}
-          end
-        end
-      end
+      super
+
+      subclass.is_loaded_blocks.push(*is_loaded_blocks)
+    end
+
+    def element_attributes
+      @element_attributes ||= {}
+    end
+
+    def is_loaded_blocks
+      @is_loaded_blocks ||= []
+    end
+
+    def is_loaded(&block)
+      self.is_loaded_blocks << block
     end
 
     def element(name, options = {}, &block)

data/lib/ae_page_objects/document_loader.rb

@@ -1,9 +1,5 @@
-require 'ae_page_objects/util/page_polling'
-
 module AePageObjects
   class DocumentLoader
-    include AePageObjects::PagePolling
-
     def initialize(query, strategy)
       @query    = query
       @strategy = strategy
@@ -11,14 +7,10 @@ module AePageObjects
 
     def load
       begin
-        poll_until do
+        AePageObjects.wait_until do
           @query.conditions.each do |document_condition|
-            begin
-              if document = @strategy.load_document_with_condition(document_condition)
-                return document
-              end
-            rescue => e
-              raise unless catch_poll_util_error?(e)
+            if document = @strategy.load_document_with_condition(document_condition)
+              return document
             end
           end
 

data/lib/ae_page_objects/element.rb

@@ -95,15 +95,15 @@ module AePageObjects
     end
 
     def scoped_node
-      if @locator
-        locator = eval_locator(@locator)
-        if ! locator.empty?
-          return parent.node.find(*locator)
-        end
+      locator = eval_locator(@locator)
+      if locator.empty?
+        parent.node
+      else
+        node = AePageObjects.wait_until { parent.node.first(*locator) }
+        node.allow_reload!
+        node
       end
-
-      parent.node
-    rescue Capybara::ElementNotFound => e
+    rescue AePageObjects::WaitTimeoutError => e
       raise LoadingElementFailed, e.message
     end
   end

data/lib/ae_page_objects/element_proxy.rb

@@ -1,5 +1,3 @@
-require 'ae_page_objects/util/page_polling'
-
 module AePageObjects
   class ElementProxy
     # Remove all instance methods so even things like class()
@@ -10,8 +8,6 @@ module AePageObjects
       end
     end
 
-    include AePageObjects::PagePolling
-
     def initialize(element_class, *args)
       @element_class = element_class
       @args          = args
@@ -121,16 +117,12 @@ module AePageObjects
 
     def reload_element
       @loaded_element = load_element
-
-      true
     rescue LoadingElementFailed
       @loaded_element = nil
-
-      true
     end
 
     def with_reloaded_element(timeout)
-      poll_until(timeout) do
+      AePageObjects.wait_until(timeout) do
         reload_element
         yield
       end

data/lib/ae_page_objects/exceptions.rb

@@ -10,34 +10,31 @@ module AePageObjects
   class LoadingElementFailed < Error
   end
 
-  class ElementExpectationError < Error
-  end
-
-  class ElementNotVisible < ElementExpectationError
+  class PathNotResolvable < Error
   end
 
-  class ElementNotHidden < ElementExpectationError
+  class DocumentLoadError < Error
   end
 
-  class ElementNotPresent < ElementExpectationError
+  class CastError < Error
   end
 
-  class ElementNotAbsent < ElementExpectationError
+  class WindowNotFound < Error
   end
 
-  class PathNotResolvable < Error
+  class WaitTimeoutError < Error
   end
 
-  class DocumentLoadError < Error
+  class ElementNotVisible < WaitTimeoutError
   end
 
-  class CastError < Error
+  class ElementNotHidden < WaitTimeoutError
   end
 
-  class WindowNotFound < Error
+  class ElementNotPresent < WaitTimeoutError
   end
 
-  class WaitTimeoutError < Error
+  class ElementNotAbsent < WaitTimeoutError
   end
 
   class FrozenInTime < Error

data/lib/ae_page_objects/node.rb

@@ -1,4 +1,5 @@
 require 'ae_page_objects/core/dsl'
+require 'ae_page_objects/element_proxy'
 
 module AePageObjects
   class Node
@@ -14,6 +15,14 @@ module AePageObjects
       end
     end
 
+    is_loaded do
+      if locator = loaded_locator
+        node.first(*eval_locator(locator)) != nil
+      else
+        true
+      end
+    end
+
     def initialize(capybara_node)
       @node  = capybara_node
       @stale = false
@@ -49,7 +58,7 @@ module AePageObjects
       self.class.current_url_without_params
     end
 
-    METHODS_TO_DELEGATE_TO_NODE = [:find, :all, :value, :set, :text, :visible?]
+    METHODS_TO_DELEGATE_TO_NODE = [:value, :set, :text, :visible?]
     METHODS_TO_DELEGATE_TO_NODE.each do |m|
       class_eval <<-RUBY
         def #{m}(*args, &block)
@@ -88,13 +97,16 @@ module AePageObjects
     end
 
     def ensure_loaded!
-      if locator = loaded_locator
-        find(*eval_locator(locator))
-      end
-
-      self
-    rescue Capybara::ElementNotFound => e
+      AePageObjects.wait_until { is_loaded? }
+    rescue AePageObjects::WaitTimeoutError => e
       raise LoadingElementFailed, e.message
     end
+
+    # This should not block and instead attempt to return immediately (e.g. use #all / #first
+    # instead of #find / #has_selector ). Unfortunately, this is difficult to enforce since even
+    # with #all / #first capyabara may wait.
+    def is_loaded?
+      self.class.is_loaded_blocks.all? { |block| self.instance_eval(&block) }
+    end
   end
 end

data/lib/ae_page_objects/single_window/same_window_loader_strategy.rb

@@ -25,7 +25,7 @@ module AePageObjects
 
       def condition_matches?(document, condition)
         condition.match?(document)
-      rescue ElementExpectationError, LoadingElementFailed
+      rescue LoadingElementFailed
         false
       end
     end

data/lib/ae_page_objects/util/wait_time_manager.rb

@@ -0,0 +1,20 @@
+module AePageObjects
+  class WaitTimeManager
+    def initialize(min_time, max_time)
+      @wait_time = min_time
+      @max_time = max_time
+    end
+
+    def using_wait_time
+      start_time = Time.now
+      @wait_time = [@wait_time, @max_time].min
+      Capybara.using_wait_time(@wait_time) do
+        yield
+      end
+    ensure
+      if Time.now - start_time > @wait_time
+        @wait_time *= 2
+      end
+    end
+  end
+end

data/lib/ae_page_objects/version.rb

@@ -1,3 +1,3 @@
 module AePageObjects
-  VERSION = '2.1.0'.freeze
+  VERSION = '3.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ae_page_objects
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Donnie Tognazzini
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-10 00:00:00.000000000 Z
+date: 2016-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capybara
@@ -58,7 +58,7 @@ files:
 - lib/ae_page_objects/single_window/window.rb
 - lib/ae_page_objects/util/hash_symbolizer.rb
 - lib/ae_page_objects/util/internal_helpers.rb
-- lib/ae_page_objects/util/page_polling.rb
+- lib/ae_page_objects/util/wait_time_manager.rb
 - lib/ae_page_objects/version.rb
 homepage: http://github.com/appfolio/ae_page_objects
 licenses:

data/lib/ae_page_objects/util/page_polling.rb

@@ -1,53 +0,0 @@
-module AePageObjects
-  module PagePolling
-    # Quickly polls the block until it returns (as opposed to throwing an exception). Using poll
-    # is a safer alternative to,
-    #
-    # Capybara.using_wait_time(0) do
-    #   has_content?('Admin')
-    # end
-    #
-    # where we want to determine whether 'Admin' is on the page (without waiting for it to appear).
-    # This is often used to switch login / functionality of page objects based on the state of the
-    # page.
-    #
-    # With poll, the above patterns becomes,
-    #
-    # AePageObjects.poll do
-    #   has_content?('Admin')
-    # end
-    def poll(seconds_to_wait = nil, &block)
-      result = nil
-      poll_until(seconds_to_wait) do
-        result = block.call
-        true
-      end
-      result
-    end
-
-    # Quickly polls the block until it returns something truthy. This is a helper function for
-    # special cases and probably NOT what you want to use. See AePageObjects#wait_until or
-    # #poll.
-    def poll_until(seconds_to_wait = nil, &block)
-      AePageObjects.wait_until(seconds_to_wait) do
-        # Capybara normally catches errors and retries. However, with the wait time of zero,
-        # capybara catches the errors and immediately reraises them. So we have to catch
-        # those errors in the similar fashion to capybara such that we properly can wait the
-        # whole seconds_to_wait.
-        begin
-          Capybara.using_wait_time(0, &block)
-        rescue => e
-          raise unless catch_poll_until_error?(e)
-          nil
-        end
-      end
-    end
-
-    def catch_poll_until_error?(error)
-      types = Capybara.current_session.driver.invalid_element_errors + [Capybara::ElementNotFound]
-      types.any? do |type|
-        error.is_a?(type)
-      end
-    end
-  end
-end