capybara-lockstep 0.2.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58ff0d51fafccaca566a89722c750b18db169331d57070c5db7d5de32620d648
-  data.tar.gz: f6f859ded650d9b2dba0c43bbb7b19333e505ed57aa0d883b0a2981e5928f1a8
+  metadata.gz: 86fa6ca6223224f8ac4b53c973cf961287964d11b129d8aa89b7b4dc81d4bba4
+  data.tar.gz: f250e201b8ef467fd46d1e30654d8e2c88366c23ad8cb314e1031cb44268dcd7
 SHA512:
-  metadata.gz: 4c1ba4546483509650a7423d04e0acffaf286db556ae431152076478e5d2ca7611a915e9f666c077d9c9c205cb4703d2cf29341e52a0b39493c4b11b78e6a883
-  data.tar.gz: 1e890d3d985af8ce4d623778781cfc06a1242d83d1c93b98bc550997e3044066544dc15100ccdb28e89090e1b865d7720200a84f8461984655b0f87fcf795281
+  metadata.gz: 846816f82797d02dc81869e449afaf99c3fdfe89682d6584a56b3416cbb5942138a38ae457dfebcbb4fc7f20ed2673766a02287911b258445c5a9b800d613f9c
+  data.tar.gz: 30064e290e2caed298e5868b0f1cb9c1f5aa34444895fa8cefd4d283b0433528dd1ee7793526f0652fbc11511ed3e50e9a6eb999b00f6a898411480616422199

data/Gemfile

@@ -8,3 +8,5 @@ gemspec
 gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
+
+gem 'byebug'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    capybara-lockstep (0.2.2)
+    capybara-lockstep (0.3.3)
       activesupport (>= 3.2)
       capybara (>= 2.0)
       selenium-webdriver (>= 3)
@@ -9,13 +9,15 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (5.2.4.3)
+    activesupport (6.1.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
     addressable (2.7.0)
       public_suffix (>= 2.0.2, < 5.0)
+    byebug (11.1.3)
     capybara (3.35.3)
       addressable
       mini_mime (>= 0.1.3)
@@ -25,13 +27,15 @@ GEM
       regexp_parser (>= 1.5, < 3.0)
       xpath (~> 3.2)
     childprocess (3.0.0)
-    concurrent-ruby (1.1.7)
+    concurrent-ruby (1.1.8)
     diff-lcs (1.3)
-    i18n (1.8.2)
+    i18n (1.8.9)
       concurrent-ruby (~> 1.0)
     mini_mime (1.0.2)
-    minitest (5.14.1)
-    nokogiri (1.11.1-x86_64-linux)
+    mini_portile2 (2.5.0)
+    minitest (5.14.4)
+    nokogiri (1.11.1)
+      mini_portile2 (~> 2.5.0)
       racc (~> 1.4)
     public_suffix (4.0.6)
     racc (1.5.2)
@@ -53,20 +57,21 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.7.0)
     rspec-support (3.7.0)
-    rubyzip (1.3.0)
+    rubyzip (2.3.0)
     selenium-webdriver (3.142.7)
       childprocess (>= 0.5, < 4.0)
       rubyzip (>= 1.2.2)
-    thread_safe (0.3.6)
-    tzinfo (1.2.7)
-      thread_safe (~> 0.1)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
     xpath (3.2.0)
       nokogiri (~> 1.8)
+    zeitwerk (2.4.2)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  byebug
   capybara-lockstep!
   rake (~> 13.0)
   rspec (~> 3.0)

data/README.md

@@ -59,7 +59,7 @@ Installation
 Check if your application satisfies all requirements for capybara-lockstep:
 
 - Capybara 2 or higher.
-- Your Capybara driver must use [selenium-webdriver](https://rubygems.org/gems/selenium-webdriver/). capybara-headless deactivates itself for any other driver.
+- Your Capybara driver must use [selenium-webdriver](https://rubygems.org/gems/selenium-webdriver/). capybara-lockstep deactivates itself for any other driver.
 - This gem was only tested with a Selenium-controlled Chrome browser. [Chrome in headless mode](https://makandracards.com/makandra/492109-running-capybara-tests-in-headless-chrome) is recommended, but not required.
 - This gem was only tested with Rails, but there's no Rails dependency.
 
@@ -170,9 +170,13 @@ app.directive('body', function() {
 
 capybara-lockstep will automatically patch Capybara to wait for the browser after every command.
 
-Run your test suite to see if integration was successful and whether stability improves.
+Run your test suite to see if integration was successful and whether stability improves. During validation we recommend to activate `Capybara::Lockstep.debug = true` in your `spec_helper.rb` (RSpec) or `env.rb` (Cucumber). You should see messages like this in your console:
 
-When you run into issues or don't see an effect, try activating `Capybara::Lockstep.debug = true` in your `spec_helper.rb` (RSpec) or `env.rb` (Cucumber).
+```text
+[capybara-lockstep] Synchronizing
+[capybara-lockstep] Finished waiting for JavaScript
+[capybara-lockstep] Synchronized successfully
+```
 
 Note that you may see some failures from tests with wrong assertions, which sometimes passed due to lucky timing.
 
@@ -183,7 +187,7 @@ capybara-lockstep may or may not impact the runtime of your test suite. It depen
 
 While waiting for the browser to be idle does take a few milliseconds, Capybara no longer needs to retry failed commands. You will also save time from not needing to re-run failed tests.
 
-In casual testing I experienced a negative performance impact between 0% and 10%.
+In casual testing I experienced a performance impact between +/- 10%.
 
 
 ## Debugging log
@@ -197,7 +201,9 @@ Capybara::Lockstep.debug = true
 You should now see messages like this during your test runs:
 
 ```
-[Capybara::Lockstep] JavaScript or AJAX requests are running
+[capybara-lockstep] Synchronizing
+[capybara-lockstep] Finished waiting for JavaScript
+[capybara-lockstep] Synchronized successfully
 ```
 
 You may also configure logging to an existing logger object:
@@ -220,7 +226,6 @@ ensure
 end
 ```
 
-
 ## Timeout
 
 By default capybara-lockstep will wait up to 10 seconds for the page initialize and for JavaScript and AJAX request to finish.
@@ -231,8 +236,28 @@ You can configure a different timeout:
 Capybara::Lockstep.timeout = 5 # seconds
 ```
 
+## Ruby API
+
+capybara-lockstep will automatically patch Capybara to wait for the browser after every command. **This should be enough for most test suites**.
+
+For additional edge cases you may interact with capybara-lockstep from your Ruby code.
+
+
+### Waiting until the browser is idle
 
+This will block until the document was loaded, the DOM has been hydrated and all AJAX requests have concluded:
 
+```ruby
+Capybara::Lockstep.synchronize
+```
+
+An example use case is a Cucumber step that explicitely waits for JavaScript to finish, in the rare occasion where capybara-lockstep hasn't picked up an event or request:
+
+```gherkin
+When 'I wait for the page to load' do
+  Capybara::Lockstep.synchronize
+end
+```
 
 ## JavaScript API
 
@@ -270,55 +295,29 @@ CapybaraLockstep.isIdle() // => true
 
 ### Waiting until the browser is idle
 
-```js
-CapybaraLockstep.awaitIdle(callback)
-```
+This will run the given callback once the browser is considered to be idle:
 
-## Ruby API
-
-capybara-lockstep will automatically patch Capybara to wait for the browser after every command. **This should be enough for most test suites**.
-
-For additional edge cases you may interact with capybara-lockstep from your Ruby code.
-
-
-### Waiting until the browser is idle
-
-This will block until the document was loaded and the DOM has been hydrated:
-
-```ruby
-Capybara::Lockstep.await_initialized
-```
-
-This will block while the browser is busy with JavaScript and AJAX requests:
-
-```ruby
-Capybara::Lockstep.await_idle
-```
-
-### Checking if the browser is busy
-
-You can query capybara-lockstep whether it considers the browser to be busy or idle:
-
-```ruby
-Capybara::Lockstep.idle? # => true
-Capybara::Lockstep.busy? # => false
+```js
+CapybaraLockstep.synchronize(callback)
 ```
 
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+
 ## Contributing
 
 Pull requests are welcome on GitHub at <https://github.com/makandra/capybara-lockstep>.
 
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
+
 ## Credits
 
 Henning Koch ([@triskweline](https://twitter.com/triskweline)) from [makandra](https://makandra.com).

data/lib/capybara-lockstep.rb

@@ -10,8 +10,8 @@ end
 
 require_relative 'capybara-lockstep/version'
 require_relative 'capybara-lockstep/errors'
-require_relative 'capybara-lockstep/patiently'
 require_relative 'capybara-lockstep/configuration'
+require_relative 'capybara-lockstep/logging'
 require_relative 'capybara-lockstep/lockstep'
 require_relative 'capybara-lockstep/capybara_ext'
 require_relative 'capybara-lockstep/helper'

data/lib/capybara-lockstep/capybara_ext.rb

@@ -1,26 +1,44 @@
 module Capybara
   module Lockstep
     module VisitWithWaiting
-      def visit(*args, **kwargs, &block)
-        super(*args, **kwargs, &block).tap do
-          # There is a step that changes drivers mid-scenario.
-          # It works by creating a new Capybara session and re-visits the
-          # URL from the previous session. If this happens before a URL is ever
-          # loaded, it re-visits the URL "data:", which will never "finish"
-          # initializing.
-          unless args[0].start_with?('data:')
-            Capybara::Lockstep.await_initialized
+      def visit(*args, &block)
+        url = args[0]
+        # Some of our apps have a Cucumber step that changes drivers mid-scenario.
+        # It works by creating a new Capybara session and re-visits the URL from the
+        # previous session. If this happens before a URL is ever loaded,
+        # it re-visits the URL "data:", which will never "finish" initializing.
+        # Also when opening a new tab via Capybara, the initial URL is about:blank.
+        visiting_remote_url = !(url.start_with?('data:') || url.start_with?('about:'))
+
+        if visiting_remote_url
+          # We're about to leave this screen, killing all in-flight requests.
+          Capybara::Lockstep.synchronize
+        end
+
+        super(*args, &block).tap do
+          if visiting_remote_url
+            # puts "After visit: unsynchronizing"
+            Capybara::Lockstep.synchronized = false
           end
         end
       end
     end
+  end
+end
+
 
-    module AwaitIdle
-      def await_idle(meth)
+Capybara::Session.class_eval do
+  prepend Capybara::Lockstep::VisitWithWaiting
+end
+
+module Capybara
+  module Lockstep
+    module UnsychronizeAfter
+      def unsychronize_after(meth)
         mod = Module.new do
           define_method meth do |*args, &block|
             super(*args, &block).tap do
-              Capybara::Lockstep.await_idle
+              Capybara::Lockstep.synchronized = false
             end
           end
         end
@@ -30,10 +48,6 @@ module Capybara
   end
 end
 
-Capybara::Session.class_eval do
-  prepend Capybara::Lockstep::VisitWithWaiting
-end
-
 # Capybara 3 has driver-specific Node classes which sometimes
 # super to Capybara::Selenium::Node, but not always.
 node_classes = [
@@ -52,20 +66,38 @@ end
 
 node_classes.each do |node_class|
   node_class.class_eval do
-    extend Capybara::Lockstep::AwaitIdle
+    extend Capybara::Lockstep::UnsychronizeAfter
 
-    await_idle :set
-    await_idle :select_option
-    await_idle :unselect_option
-    await_idle :click
-    await_idle :right_click
-    await_idle :double_click
-    await_idle :send_keys
-    await_idle :hover
-    await_idle :drag_to
-    await_idle :drop
-    await_idle :scroll_by
-    await_idle :scroll_to
-    await_idle :trigger
+    unsychronize_after :set
+    unsychronize_after :select_option
+    unsychronize_after :unselect_option
+    unsychronize_after :click
+    unsychronize_after :right_click
+    unsychronize_after :double_click
+    unsychronize_after :send_keys
+    unsychronize_after :hover
+    unsychronize_after :drag_to
+    unsychronize_after :drop
+    unsychronize_after :scroll_by
+    unsychronize_after :scroll_to
+    unsychronize_after :trigger
   end
 end
+
+module Capybara
+  module Lockstep
+    module SynchronizeWithCatchUp
+      def synchronize(*args, &block)
+        # This method is called very frequently by capybara.
+        # We use the { lazy } option to only synchronize when we're out of sync.
+        Capybara::Lockstep.synchronize(lazy: true)
+
+        super(*args, &block)
+      end
+    end
+  end
+end
+
+Capybara::Node::Base.class_eval do
+  prepend Capybara::Lockstep::SynchronizeWithCatchUp
+end

data/lib/capybara-lockstep/configuration.rb

@@ -30,6 +30,10 @@ module Capybara
         @enabled = enabled
       end
 
+      def disabled?
+        !enabled?
+      end
+
       private
 
       def javascript_driver?

data/lib/capybara-lockstep/helper.js

@@ -37,7 +37,7 @@ window.CapybaraLockstep = (function() {
 
     if (isIdle()) {
       idleCallbacks.forEach(function(callback) {
-        callback('JavaScript has finished')
+        callback('Finished waiting for JavaScript')
       })
       idleCallbacks = []
     }
@@ -95,19 +95,6 @@ window.CapybaraLockstep = (function() {
     startWorkForMicrotask()
   }
 
-  function trackHistory() {
-    ['popstate'].forEach(function(eventType) {
-      document.addEventListener(eventType, onHistoryEvent)
-    })
-  }
-
-  function onHistoryEvent() {
-    // After calling history.back() or history.forward() the popstate event will *not*
-    // fire synchronously. It will also not fire in the next task. Chrome sometimes fires
-    // it after 10ms, but sometimes it takes longer.
-    startWorkForTime(100)
-  }
-
   function trackDynamicScripts() {
     if (!window.MutationObserver) {
       return
@@ -116,7 +103,7 @@ window.CapybaraLockstep = (function() {
     // Dynamic imports or analytics snippets may insert a <script src>
     // tag that loads and executes additional JavaScript. We want to be isBusy()
     // until such scripts have loaded or errored.
-    var observer = new MutationObserver(onMutated)
+    var observer = new MutationObserver(onAnyElementChanged)
     observer.observe(document, { subtree: true, childList: true })
   }
 
@@ -139,6 +126,28 @@ window.CapybaraLockstep = (function() {
     })
   }
 
+  var INITIALIZING_ATTRIBUTE = 'data-initializing'
+
+  function trackHydration() {
+    // Until we have a body on which we can observe [data-initializing]
+    // we consider ourselves busy.
+    startWork()
+    whenReady(function() {
+      stopWork()
+      if (document.body.hasAttribute(INITIALIZING_ATTRIBUTE)) {
+        startWork()
+        var observer = new MutationObserver(onInitializingAttributeChanged)
+        observer.observe(document.body, { attributes: true, attributeFilter: [INITIALIZING_ATTRIBUTE] })
+      }
+    })
+  }
+
+  function onInitializingAttributeChanged() {
+    if (!document.body.hasAttribute(INITIALIZING_ATTRIBUTE)) {
+      stopWork()
+    }
+  }
+
   function isRemoteScript(node) {
     if (node.nodeType === Node.ELEMENT_NODE && node.tagName === 'SCRIPT') {
       var src = node.getAttribute('src')
@@ -155,7 +164,7 @@ window.CapybaraLockstep = (function() {
     script.addEventListener('error', stopWork)
   }
 
-  function onMutated(changes) {
+  function onAnyElementChanged(changes) {
     changes.forEach(function(change) {
       change.addedNodes.forEach(function(addedNode) {
         if (isRemoteScript(addedNode)) {
@@ -168,7 +177,7 @@ window.CapybaraLockstep = (function() {
   function whenReady(callback) {
     // Values are "loading", "interactive" and "completed".
     // https://developer.mozilla.org/en-US/docs/Web/API/Document/readyState
-    if (document.readyState != 'loading') {
+    if (document.readyState !== 'loading') {
       callback()
     } else {
       document.addEventListener('DOMContentLoaded', callback)
@@ -179,12 +188,12 @@ window.CapybaraLockstep = (function() {
     trackFetch()
     trackXHR()
     trackInteraction()
-    trackHistory()
     trackDynamicScripts()
     trackJQuery()
+    trackHydration()
   }
 
-  function awaitIdle(callback) {
+  function synchronize(callback) {
     if (isIdle()) {
       callback()
     } else {
@@ -196,7 +205,7 @@ window.CapybaraLockstep = (function() {
     track: track,
     startWork: startWork,
     stopWork: stopWork,
-    awaitIdle: awaitIdle,
+    synchronize: synchronize,
     isIdle: isIdle,
     isBusy: isBusy
   }

data/lib/capybara-lockstep/lockstep.rb

@@ -1,102 +1,101 @@
 module Capybara
   module Lockstep
+    ERROR_SNIPPET_MISSING = 'Cannot synchronize: capybara-lockstep JavaScript snippet is missing'
+    ERROR_PAGE_MISSING = 'Cannot synchronize before initial Capybara visit'
+    ERROR_ALERT_OPEN = 'Cannot synchronize while an alert is open'
+    ERROR_NAVIGATED_AWAY = "Browser navigated away while synchronizing"
+
     class << self
-      include Patiently
       include Configuration
+      include Logging
+
+      attr_accessor :synchronizing
+      alias synchronizing? synchronizing
+
+      def synchronized?
+        value = page.instance_variable_get(:@lockstep_synchronized)
+        # We consider a new Capybara session to be synchronized.
+        # This will be set to false after our first visit().
+        value.nil? ? true : value
+      end
+
+      def synchronized=(value)
+        page.instance_variable_set(:@lockstep_synchronized, value)
+      end
+
+      def synchronize(lazy: false)
+        if (lazy && synchronized?) || synchronizing? || disabled?
+          return
+        end
+
+        synchronize_now
+      end
+
+      private
 
-      def await_idle
-        return unless enabled?
+      def synchronize_now
+        self.synchronizing = true
+        self.synchronized = false
 
-        ignoring_alerts do
-          # evaluate_async_script also times out after Capybara.default_max_wait_time
+        log 'Synchronizing'
+
+        begin
           with_max_wait_time(timeout) do
             message_from_js = evaluate_async_script(<<~JS)
               let done = arguments[0]
-              if (window.CapybaraLockstep) {
-                CapybaraLockstep.awaitIdle(done)
+              let synchronize = () => {
+                if (window.CapybaraLockstep) {
+                  CapybaraLockstep.synchronize(done)
+                } else {
+                  done(#{ERROR_SNIPPET_MISSING.to_json})
+                }
+              }
+              let protocol = location.protocol
+              if (protocol === 'data:' || protocol == 'about:') {
+                done(#{ERROR_PAGE_MISSING.to_json})
+              } else if (document.readyState === 'complete') {
+                synchronize()
               } else {
-                done('Cannot synchronize: Capybara::Lockstep was not included in page')
+                window.addEventListener('load', synchronize)
               }
             JS
-            log(message_from_js)
-          end
-        end
-      end
 
-      def await_initialized
-        return unless enabled?
-
-        # We're retrying the initialize check every few ms.
-        # Don't clutter the log with dozens of identical messages.
-        last_logged_reason = nil
-
-        patiently(timeout) do
-          if (reason = initialize_reason)
-            if reason != last_logged_reason
-              log(reason)
-              last_logged_reason = reason
+            case message_from_js
+            when ERROR_PAGE_MISSING
+              log(message_from_js)
+            when ERROR_SNIPPET_MISSING
+              log(message_from_js)
+            else
+              log message_from_js
+              log "Synchronized successfully"
+              self.synchronized = true
             end
-
-            # Raise an exception that will be retried by `patiently`
-            raise Busy, reason
           end
+        rescue ::Selenium::WebDriver::Error::UnexpectedAlertOpenError
+          log ERROR_ALERT_OPEN
+          # Don't raise an error, this will happen in an innocent test.
+          # We will retry on the next Capybara synchronize call.
+        rescue ::Selenium::WebDriver::Error::JavascriptError => e
+          # When the URL changes while a script is running, my current selenium-webdriver
+          # raises a Selenium::WebDriver::Error::JavascriptError with the message:
+          # "javascript error: document unloaded while waiting for result".
+          # We will retry on the next Capybara synchronize call, by then we should see
+          # the new page.
+          if e.message.include?('unload')
+            log ERROR_NAVIGATED_AWAY
+          else
+            unhandled_synchronize_error(e)
+          end
+        rescue StandardError => e
+          unhandled_synchronize_error(e)
+        ensure
+          self.synchronizing = false
         end
       end
 
-      def idle?
-        unless enabled?
-          return true
-        end
-
-        result = execute_script(<<~JS)
-          if (window.CapybaraLockstep) {
-            return CapybaraLockstep.isIdle()
-          } else {
-            return 'Cannot check busy state: Capybara::Lockstep was not included in page'
-          }
-        JS
-
-        if result.is_a?(String)
-          log(result)
-          # When the snippet is missing we assume that the browser is idle.
-          # Otherwise we would wait forever.
-          true
-        else
-          result
-        end
-      end
-
-      def busy?
-        !idle?
-      end
-
-      private
-
-      def initialize_reason
-        ignoring_alerts do
-          execute_script(<<~JS)
-            if (location.href.indexOf('data:') == 0) {
-              return 'Requesting initial page'
-            }
-
-            if (document.readyState !== "complete") {
-              return 'Document is loading'
-            }
-
-            // The application layouts render a <body data-initializing>.
-            // The [data-initializing] attribute is removed by an Angular directive or Unpoly compiler (frontend).
-            // to signal that all elements have been activated.
-            if (document.querySelector('body[data-initializing]')) {
-              return 'DOM is being hydrated'
-            }
-
-            if (window.CapybaraLockstep && CapybaraLockstep.isBusy()) {
-              return 'JavaScript or AJAX requests are running'
-            }
-
-            return false
-          JS
-        end
+      def unhandled_synchronize_error(e)
+        log "#{e.class.name} while synchronizing: #{e.message}"
+        raise e
       end
 
       def page
@@ -105,12 +104,6 @@ module Capybara
 
       delegate :evaluate_script, :evaluate_async_script, :execute_script, :driver, to: :page
 
-      def ignoring_alerts(&block)
-        block.call
-      rescue ::Selenium::WebDriver::Error::UnexpectedAlertOpenError
-        # noop
-      end
-
       def with_max_wait_time(seconds, &block)
         old_max_wait_time = Capybara.default_max_wait_time
         Capybara.default_max_wait_time = seconds
@@ -121,17 +114,10 @@ module Capybara
         end
       end
 
-      def log(message)
-        if debug? && message.present?
-          message = "[Capybara::Lockstep] #{message}"
-          if @debug.respond_to?(:debug)
-            # If someone set Capybara::Lockstep to a logger, use that
-            @debug.debug(message)
-          else
-            # Otherwise print to STDOUT
-            puts message
-          end
-        end
+      def ignoring_alerts(&block)
+        block.call
+      rescue ::Selenium::WebDriver::Error::UnexpectedAlertOpenError
+        # no-op
       end
 
     end

data/lib/capybara-lockstep/logging.rb

@@ -0,0 +1,18 @@
+module Capybara
+  module Lockstep
+    module Logging
+      def log(message)
+        if debug? && message.present?
+          message = "[capybara-lockstep] #{message}"
+          if @debug.respond_to?(:debug)
+            # If someone set Capybara::Lockstep to a logger, use that
+            @debug.debug(message)
+          else
+            # Otherwise print to STDOUT
+            puts message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capybara-lockstep/version.rb

@@ -1,5 +1,5 @@
 module Capybara
   module Lockstep
-    VERSION = "0.2.2"
+    VERSION = "0.3.3"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: capybara-lockstep
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Henning Koch
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-03 00:00:00.000000000 Z
+date: 2021-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capybara
@@ -77,7 +77,7 @@ files:
 - lib/capybara-lockstep/helper.js
 - lib/capybara-lockstep/helper.rb
 - lib/capybara-lockstep/lockstep.rb
-- lib/capybara-lockstep/patiently.rb
+- lib/capybara-lockstep/logging.rb
 - lib/capybara-lockstep/version.rb
 homepage: https://github.com/makandra/capybara-lockstep
 licenses:

data/lib/capybara-lockstep/patiently.rb

@@ -1,58 +0,0 @@
-module Capybara
-  module Lockstep
-    # Ported from https://github.com/makandra/spreewald/blob/master/lib/spreewald_support/tolerance_for_selenium_sync_issues.rb
-    module Patiently
-
-      RETRY_ERRORS = %w[
-        Capybara::Lockstep::Busy
-        Capybara::ElementNotFound
-        Spec::Expectations::ExpectationNotMetError
-        RSpec::Expectations::ExpectationNotMetError
-        Minitest::Assertion
-        Capybara::Poltergeist::ClickFailed
-        Capybara::ExpectationNotMet
-        Selenium::WebDriver::Error::StaleElementReferenceError
-        Selenium::WebDriver::Error::NoAlertPresentError
-        Selenium::WebDriver::Error::ElementNotVisibleError
-        Selenium::WebDriver::Error::NoSuchFrameError
-        Selenium::WebDriver::Error::NoAlertPresentError
-        Selenium::WebDriver::Error::JavascriptError
-        Selenium::WebDriver::Error::UnknownError
-        Selenium::WebDriver::Error::NoSuchAlertError
-      ]
-
-      # evaluate_script latency is ~ 0.025s
-      WAIT_PERIOD = 0.03
-
-      def patiently(timeout = Capybara.default_max_wait_time, &block)
-        started = monotonic_time
-        tries = 0
-        begin
-          tries += 1
-          block.call
-        rescue Exception => e
-          raise e unless retryable_error?(e)
-          raise e if (monotonic_time - started > timeout && tries >= 2)
-          sleep(WAIT_PERIOD)
-          if monotonic_time == started
-            raise Capybara::FrozenInTime, "time appears to be frozen, Capybara does not work with libraries which freeze time, consider using time travelling instead"
-          end
-          retry
-        end
-      end
-
-      private
-
-      def monotonic_time
-        # We use the system clock (i.e. seconds since boot) to calculate the time,
-        # because Time.now may be frozen
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-      def retryable_error?(e)
-        RETRY_ERRORS.include?(e.class.name)
-      end
-
-    end
-  end
-end