capybara-lockstep 0.2.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cccdbf8f6eb6582b123a366febeb67f863ac3801cf91f42f7a48f685e96d1860
-  data.tar.gz: a3683b8f821c8dd706eff573fb9c0e5aa730a29dd9205d2441a3ab5a52d8f0b8
+  metadata.gz: d0d733ed210e1ba465d9d612fcf461618ee91c88a71b09f9c0020271e4ac28ef
+  data.tar.gz: 5f30713c033ebd57b30d37f27e545c2a4547f6d40cd013c15f4ebba50a1f3893
 SHA512:
-  metadata.gz: e9fc97b54f2b797809c85d45d87b1d34a687ae18617bbf17bdad57d060da96eb876283610e5442cebf876ba520333e501ca635bd48436870359e0b806cfeabc0
-  data.tar.gz: 157ae6e39f58f9437f0121fc3836d2bf3ac0c767b3dff2ff59f5f9b04516fdf4586df04ecc0bbd9c021615551878735edb910fdb393b005cfda59f906832b2f2
+  metadata.gz: d8fcf72c9736d98a80661f282527f0f53affb22b5aa2b537f7e7fbc4ea246ca2886e4f798343654c984321ca3d7dfec25043fa8e70d4341558a9073ea69911fe
+  data.tar.gz: c1f5144ed73a92f33e6ac36a0838401efae44d26ec199857f0e85a99b07afcd780d558ee6f3e859ac393db11649d186c8d56f72ddd6c2629fcddd68c2af907c0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    capybara-lockstep (0.2.1)
+    capybara-lockstep (0.3.2)
       activesupport (>= 3.2)
       capybara (>= 2.0)
       selenium-webdriver (>= 3)
@@ -9,11 +9,12 @@ 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)
     capybara (3.35.3)
@@ -25,13 +26,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,15 +56,15 @@ 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

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/capistrano-lockstep>.
+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/capybara-lockstep.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["henning.koch@makandra.de"]
 
   spec.summary       = "Synchronize Capybara commands with client-side JavaScript and AJAX requests"
-  spec.homepage      = "https://rubygems.org/gems/capybara-lockstep"
+  spec.homepage      = "https://github.com/makandra/capybara-lockstep"
   spec.license       = "MIT"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
 

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 = []
     }
@@ -116,7 +116,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 +139,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 +177,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 +190,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)
@@ -182,9 +204,10 @@ window.CapybaraLockstep = (function() {
     trackHistory()
     trackDynamicScripts()
     trackJQuery()
+    trackHydration()
   }
 
-  function awaitIdle(callback) {
+  function synchronize(callback) {
     if (isIdle()) {
       callback()
     } else {
@@ -196,7 +219,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,116 +1,91 @@
 module Capybara
   module Lockstep
     class << self
-      include Patiently
       include Configuration
+      include Logging
 
-      def await_idle
-        return unless enabled?
+      attr_accessor :synchronized
 
-        ignoring_alerts do
-          # evaluate_async_script also times out after Capybara.default_max_wait_time
+      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
+
+      ERROR_SNIPPET_MISSING = 'Cannot synchronize: Capybara::Lockstep JavaScript snippet is missing on page'
+      ERROR_PAGE_MISSING = 'Cannot synchronize before initial Capybara visit'
+      ERROR_ALERT_OPEN = 'Cannot synchronize while an alert is open'
+
+      def synchronize(lazy: false)
+        if (lazy && synchronized?) || @synchronizing || disabled?
+          return
+        end
+
+        @synchronizing = true
+
+        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)
+              self.synchronized = false
+            when ERROR_SNIPPET_MISSING
+              log(message_from_js)
+              self.synchronized = false
+            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
+          @synchronized = false
+          # Don't raise an error, this will happen in an innocent test.
+          # We will retry on the next Capybara synchronize call.
+        rescue StandardError => e
+          log "#{e.class.name} while synchronizing: #{e.message}"
+          @synchronized = false
+          raise e
+        ensure
+          @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
-      end
-
       def page
         Capybara.current_session
       end
 
       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 +96,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.1"
+    VERSION = "0.3.2"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: capybara-lockstep
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Henning Koch
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-03 00:00:00.000000000 Z
+date: 2021-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capybara
@@ -77,14 +77,14 @@ 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://rubygems.org/gems/capybara-lockstep
+homepage: https://github.com/makandra/capybara-lockstep
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://rubygems.org/gems/capybara-lockstep
-  source_code_uri: https://rubygems.org/gems/capybara-lockstep
+  homepage_uri: https://github.com/makandra/capybara-lockstep
+  source_code_uri: https://github.com/makandra/capybara-lockstep
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -100,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.6
+rubygems_version: 3.2.5
 signing_key: 
 specification_version: 4
 summary: Synchronize Capybara commands with client-side JavaScript and AJAX requests

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