capybara-lockstep 1.3.1 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 963aaa637f5f364f53f2a16087accf68035381e260aa4f7b0b2703d9a00a8abb
-  data.tar.gz: a48cdd51fc2fcf9e6d87d0d692e1448c90a639d36695b38e97d4a1183a44043c
+  metadata.gz: f264c637e6de9b4a6ab18e1e33ebf3c81fe46a9a20173b5c4c8097f5be4d8ae6
+  data.tar.gz: f48886c96cbdfe898d5245a85955b76a5caee1c64662e4e12823427b7cb6c883
 SHA512:
-  metadata.gz: 8e2ab4e0227f8f3511e40b82ba0dfe80df61615547c6291db4f0d16bfa097a1863e612d57bd6d16c86bd5e5a4a9cd8be3f6040cdf3138071d487311dcfbb5b1f
-  data.tar.gz: 0060560ae282df788924891c6fff31cdf27491e79468f6c172154667466f66784bce54920e31d0838b96ad91d84904f8cb859573c390a5a327b8e4c40351d2f5
+  metadata.gz: c959856af42047611c8c90b4b9c2de6a0a201ba9bff3f5ae9f2bc0a1e32026999283253c6d7ace66305364c57550dc20b5ee131251dcbf80cec707b47994bb30
+  data.tar.gz: be4f33cb2e453d1bf830a75d70a55ffdb43c243ccf0f9d0513bf578b88d0aec6fca135cb4c16f6f13096edd52d44c190794f480ba35140ec965c32e09ddafa6f

data/CHANGELOG.md

@@ -2,6 +2,17 @@ All notable changes to this project will be documented in this file.
 
 This project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+
+# 2.0.0-rc1
+
+- We now synchronize before a user interaction. Previously we only synchronized before an observation. This could lead to race conditions when a test chained multiple interactions without [making an observation in between](https://makandracards.com/makandra/47336-fixing-flaky-e2e-tests#section-interleave-actions-and-expectations).
+- We now synchronize after a user interaction (e.g. after a click). Previously we only synchronized before an observation. This could lead to race conditions when a test made assertions without going to Capybara, e.g. by accessing the database or global state variables.
+- When a job ends (e.g. an AJAX request finishes) we now wait for one [JavaScript task](https://jakearchibald.com/2015/tasks-microtasks-queues-and-schedules/). This gives event listeners more time to schedule new async work.
+- We now wait one JavaScript task after `touchstart`, `mousedown`, `click` and `keydown` events. This gives event listeners more time to schedule async work after a user interaction.
+- You can now wait while the backend server is busy, by using `Capybara::Lockstep::Middleware` in your Rails or Rack app. We previously only waited for AJAX requests on the client, but using the middleware addresses some additional edge cases. For example, the middleware detects requests that were aborted on the frontend, but are still being processed by the backend.
+- You can signal async work from the backend, e.g. for background jobs. Note that you don't need to signal work for the regular request/response cycle, as this is detected automatically.
+
+
 ## 1.3.1 - 2023-10-25
 
 Now synchronizes before and after `evaluate_script`.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    capybara-lockstep (1.3.1)
+    capybara-lockstep (2.0.0.rc1)
       activesupport (>= 3.2)
       capybara (>= 2.0)
       ruby2_keywords

data/lib/capybara-lockstep/capybara_ext.rb

@@ -2,13 +2,27 @@ require 'ruby2_keywords'
 
 module Capybara
   module Lockstep
-    module UnsychronizeAfter
-      def unsychronize_after(meth)
+    module SynchronizeMacros
+
+      def synchronize_before(meth, lazy:)
+        mod = Module.new do
+          define_method meth do |*args, &block|
+            Lockstep.auto_synchronize(lazy: lazy, log: "Synchronizing before ##{meth}")
+            super(*args, &block)
+          end
+
+          ruby2_keywords meth
+        end
+
+        prepend(mod)
+      end
+
+      def synchronize_after(meth)
         mod = Module.new do
           define_method meth do |*args, &block|
             super(*args, &block)
           ensure
-            Lockstep.synchronized = false
+            Lockstep.auto_synchronize
           end
 
           ruby2_keywords meth
@@ -16,18 +30,13 @@ module Capybara
 
         prepend(mod)
       end
-    end
-  end
-end
 
-module Capybara
-  module Lockstep
-    module SynchronizeBefore
-      def synchronize_before(meth, lazy:)
+      def unsynchronize_after(meth)
         mod = Module.new do
           define_method meth do |*args, &block|
-            Lockstep.auto_synchronize(lazy: lazy, log: "Synchronizing before ##{meth}")
             super(*args, &block)
+          ensure
+            Lockstep.unsynchronize
           end
 
           ruby2_keywords meth
@@ -35,32 +44,32 @@ module Capybara
 
         prepend(mod)
       end
+
     end
   end
 end
 
 Capybara::Session.class_eval do
-  extend Capybara::Lockstep::SynchronizeBefore
-  extend Capybara::Lockstep::UnsychronizeAfter
+  extend Capybara::Lockstep::SynchronizeMacros
 
   synchronize_before :html, lazy: true # wait until running JavaScript has updated the DOM
 
   synchronize_before :current_url, lazy: true # wait until running JavaScript has updated the URL
 
   synchronize_before :refresh, lazy: false # wait until running JavaScript has updated the URL
-  unsychronize_after :refresh # new document is no longer synchronized
+  unsynchronize_after :refresh # new document is no longer synchronized
 
   synchronize_before :go_back, lazy: false # wait until running JavaScript has updated the URL
-  unsychronize_after :go_back # new document is no longer synchronized
+  unsynchronize_after :go_back # new document is no longer synchronized
 
   synchronize_before :go_forward, lazy: false # wait until running JavaScript has updated the URL
-  unsychronize_after :go_forward # new document is no longer synchronized
+  unsynchronize_after :go_forward # new document is no longer synchronized
 
   synchronize_before :switch_to_frame, lazy: true # wait until the current frame is done processing
-  unsychronize_after :switch_to_frame # now that we've switched into the new frame, we don't know the document's synchronization state.
+  unsynchronize_after :switch_to_frame # now that we've switched into the new frame, we don't know the document's synchronization state.
 
   synchronize_before :switch_to_window, lazy: true # wait until the current frame is done processing
-  unsychronize_after :switch_to_window # now that we've switched to the new window, we don't know the document's synchronization state.
+  unsynchronize_after :switch_to_window # now that we've switched to the new window, we don't know the document's synchronization state.
 end
 
 module Capybara
@@ -88,7 +97,7 @@ module Capybara
         super(*args, &block).tap do
           if visiting_real_url
             # We haven't yet synchronized the new screen.
-            Lockstep.synchronized = false
+            Lockstep.unsynchronize
           end
         end
       end
@@ -128,7 +137,7 @@ module Capybara
             if !Lockstep.synchronizing?
               # We haven't yet synchronized with whatever changes the JavaScript
               # did on the frontend.
-              Lockstep.synchronized = false
+              Lockstep.unsynchronize
             end
           end
 
@@ -167,21 +176,59 @@ end
 
 node_classes.each do |node_class|
   node_class.class_eval do
-    extend Capybara::Lockstep::UnsychronizeAfter
-
-    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
+    extend Capybara::Lockstep::SynchronizeMacros
+
+    synchronize_before :set, lazy: true
+    unsynchronize_after :set
+    synchronize_after :set
+
+    synchronize_before :select_option, lazy: true
+    unsynchronize_after :select_option
+    synchronize_after :select_option
+
+    synchronize_before :unselect_option, lazy: true
+    unsynchronize_after :unselect_option
+    synchronize_after :unselect_option
+
+    synchronize_before :click, lazy: true
+    unsynchronize_after :click
+    synchronize_after :click
+
+    synchronize_before :right_click, lazy: true
+    unsynchronize_after :right_click
+    synchronize_after :right_click
+
+    synchronize_before :double_click, lazy: true
+    unsynchronize_after :double_click
+    synchronize_after :double_click
+
+    synchronize_before :send_keys, lazy: true
+    unsynchronize_after :send_keys
+    synchronize_after :send_keys
+
+    synchronize_before :hover, lazy: true
+    unsynchronize_after :hover
+    synchronize_after :hover
+
+    synchronize_before :drag_to, lazy: true
+    unsynchronize_after :drag_to
+    synchronize_after :drag_to
+
+    synchronize_before :drop, lazy: true
+    unsynchronize_after :drop
+    synchronize_after :drop
+
+    synchronize_before :scroll_by, lazy: true
+    unsynchronize_after :scroll_by
+    synchronize_after :scroll_by
+
+    synchronize_before :scroll_to, lazy: true
+    unsynchronize_after :scroll_to
+    synchronize_after :scroll_to
+
+    synchronize_before :trigger, lazy: true
+    unsynchronize_after :trigger
+    synchronize_after :trigger
   end
 end
 

data/lib/capybara-lockstep/client.rb

@@ -0,0 +1,133 @@
+module Capybara
+  module Lockstep
+    class Client
+      include Logging
+      include PageAccess
+
+      ERROR_SNIPPET_MISSING = 'Cannot synchronize: capybara-lockstep JavaScript snippet is missing'
+      ERROR_PAGE_MISSING = 'Cannot synchronize with empty page'
+      ERROR_ALERT_OPEN = 'Cannot synchronize while an alert is open'
+      ERROR_NAVIGATED_AWAY = "Browser navigated away while synchronizing"
+
+      SYNCHRONIZED_IVAR = :@lockstep_synchronized_client
+
+      def synchronized?
+        # The synchronized flag is per-session (page == Capybara.current_session).
+        # This enables tests that use more than one browser, e.g. to test multi-user interaction:
+        # https://makandracards.com/makandra/474480-how-to-make-a-cucumber-test-work-with-multiple-browser-sessions
+        #
+        # Ideally the synchronized flag would also be per-tab, per-frame and per-document.
+        # We haven't found a way to patch this into Capybara, as there does not seem to be
+        # a persistent object representing a document. Capybara::Node::Document just seems to
+        # be a proxy accessing whatever is the current document. The way we work around this
+        # is that we synchronize before switching tabs or frames.
+        value = page.instance_variable_get(SYNCHRONIZED_IVAR)
+
+        # 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(SYNCHRONIZED_IVAR, value)
+      end
+
+      def synchronize
+        # If synchronization fails below we consider us unsynchronized after.
+        self.synchronized = false
+
+        # Running the synchronization script while an alert is open would close the alert,
+        # most likely causing subsequent expectations to fail.
+        if alert_present?
+          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.
+          return
+        end
+
+        start_time = Util.current_seconds
+
+        begin
+          Util.with_max_wait_time(timeout) do
+            message_from_js = evaluate_async_script(<<~JS)
+              let done = arguments[0]
+              let synchronize = () => {
+                if (window.CapybaraLockstep) {
+                  CapybaraLockstep.synchronize(done)
+                } else {
+                  done(#{ERROR_SNIPPET_MISSING.to_json})
+                }
+              }
+              const emptyDataURL = /^data:[^,]*,?$/
+              if (emptyDataURL.test(location.href) || location.protocol === 'about:') {
+                done(#{ERROR_PAGE_MISSING.to_json})
+              } else if (document.readyState === 'complete') {
+                // WebDriver always waits for the `load` event after a visit(),
+                // unless a different page load strategy was configured.
+                synchronize()
+              } else {
+                window.addEventListener('load', synchronize)
+              }
+            JS
+
+            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
+              end_time = Util.current_seconds
+              ms_elapsed = ((end_time.to_f - start_time) * 1000).round
+              log "Synchronized client successfully [#{ms_elapsed} ms]"
+              self.synchronized = true
+            end
+          end
+        rescue ::Selenium::WebDriver::Error::ScriptTimeoutError
+          timeout_message = "Could not synchronize client within #{timeout} seconds"
+          log timeout_message
+          if timeout_with == :error
+            raise Timeout, timeout_message
+          else
+            # Don't raise an error, this may happen if the server is slow to respond.
+            # We will retry on the next Capybara synchronize call.
+          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)
+        end
+      end
+
+      private
+
+      def unhandled_synchronize_error(e)
+        Lockstep.log "#{e.class.name} while synchronizing: #{e.message}"
+        raise e
+      end
+
+      def timeout
+        Lockstep.timeout
+      end
+
+      def timeout_with
+        Lockstep.timeout_with
+      end
+
+    end
+  end
+end
+

data/lib/capybara-lockstep/configuration.rb

@@ -18,9 +18,13 @@ module Capybara
         @timeout_with = action&.to_sym
       end
 
+      def debug
+        @debug.nil? ? false : @debug
+      end
+
       def debug?
         # @debug may also be a Logger object, so convert it to a boolean
-        @debug.nil? ? false : !!@debug
+        !!debug
       end
 
       def debug=(value)
@@ -93,13 +97,11 @@ module Capybara
         end
       end
 
-      def javascript_driver?
-        driver.is_a?(Capybara::Selenium::Driver)
-      end
-
       def send_config_to_browser(js)
+        return unless javascript_driver?
+
         begin
-          with_max_wait_time(2) do
+          Util.with_max_wait_time(2) do
             page.execute_script(<<~JS)
               if (window.CapybaraLockstep) {
                 #{js}

data/lib/capybara-lockstep/helper.js

@@ -11,7 +11,7 @@ window.CapybaraLockstep = (function() {
     jobCount = 0
     idleCallbacks = []
     finishedWorkTags = []
-    waitTasks = 0
+    waitTasks = 1
     debug = false
   }
 
@@ -58,18 +58,7 @@ window.CapybaraLockstep = (function() {
   }
 
   function stopWork(tag) {
-    let tasksElapsed = 0
-
-    let check = function() {
-      if (tasksElapsed < waitTasks) {
-        tasksElapsed++
-        setTimeout(check)
-      } else {
-        stopWorkNow(tag)
-      }
-    }
-
-    check()
+    afterWaitTasks(stopWorkNow.bind(this, tag))
   }
 
   function stopWorkNow(tag) {
@@ -266,6 +255,14 @@ window.CapybaraLockstep = (function() {
     }
   }
 
+  function afterWaitTasks(fn, tasksLeft = waitTasks) {
+    if (tasksLeft > 0) {
+      afterWaitTasks(fn, tasksLeft - 1)
+    } else {
+      fn()
+    }
+  }
+
   function trackOldUnpoly() {
     // CapybaraLockstep.track() is called as the first script in the head.
     // Unpoly will be loaded after us, so we wait until DOMContentReady.
@@ -282,12 +279,28 @@ window.CapybaraLockstep = (function() {
     })
   }
 
+  function trackInteraction(eventType) {
+    document.addEventListener(eventType, function() {
+      // Only litter the log with interaction events if we're actually going
+      // to be busy for at least 1 task.
+      if (waitTasks > 0) {
+        let tag = eventType + ' listeners'
+        startWork(tag)
+        stopWork(tag)
+      }
+    })
+  }
+
   function track() {
     trackOldUnpoly()
     trackFetch()
     trackXHR()
     trackRemoteElements()
     trackJQuery()
+    trackInteraction('touchstart')
+    trackInteraction('mousedown')
+    trackInteraction('click')
+    trackInteraction('keydown')
   }
 
   function synchronize(callback) {

data/lib/capybara-lockstep/lockstep.rb

@@ -1,39 +1,31 @@
 module Capybara
   module Lockstep
-    ERROR_SNIPPET_MISSING = 'Cannot synchronize: capybara-lockstep JavaScript snippet is missing'
-    ERROR_PAGE_MISSING = 'Cannot synchronize with empty page'
-    ERROR_ALERT_OPEN = 'Cannot synchronize while an alert is open'
-    ERROR_NAVIGATED_AWAY = "Browser navigated away while synchronizing"
-
     class << self
       include Configuration
       include Logging
+      include PageAccess
 
       attr_accessor :synchronizing
       alias synchronizing? synchronizing
 
-      def synchronized?
-        # The synchronized flag is per-session (page == Capybara.current_session).
-        # This enables tests that use more than one browser, e.g. to test multi-user interaction:
-        # https://makandracards.com/makandra/474480-how-to-make-a-cucumber-test-work-with-multiple-browser-sessions
-        #
-        # Ideally the synchronized flag would also be per-tab, per-frame and per-document.
-        # We haven't found a way to patch this into Capybara, as there does not seem to be
-        # a persistent object representing a document. Capybara::Node::Document just seems to
-        # be a proxy accessing whatever is the current document. The way we work around this
-        # is that we synchronize before switching tabs or frames.
-        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
+      def unsynchronize
+        client.synchronized = false
       end
 
-      def synchronized=(value)
-        page.instance_variable_set(:@lockstep_synchronized, value)
+      # Automatic synchronization from within the capybara-lockstep should always call #auto_synchronize.
+      # This only synchronizes IFF in :auto mode, i.e. the user has not explicitly disabled automatic syncing.
+      # The :auto mode has nothing to do with the { lazy } option.
+      def auto_synchronize(**options)
+        if mode == :auto
+          synchronize(**options)
+        end
       end
 
-      def synchronize(lazy: false, log: nil)
+      def synchronize(lazy: false, log: 'Synchronizing')
+        if synchronizing? || mode == :off
+          return
+        end
+
         # The { lazy } option is a performance optimization that will prevent capybara-lockstep
         # from synchronizing multiple times in expressions like `page.find('.foo').find('.bar')`.
         # The { lazy } option has nothing todo with :auto mode.
@@ -48,135 +40,38 @@ module Capybara
         # thinks we're in sync or not. This always makes an execute_script() rountrip, but picks up
         # non-lazy synchronization so we pick up client-side work that have not been caused
         # by Capybara commands.
-        if (lazy && synchronized?) || synchronizing? || mode == :off
-          return
-        end
-
-        synchronize_now(log: log)
-
-        run_after_synchronize_callbacks
-      end
-
-      # Automatic synchronization from within the capybara-lockstep should always call #auto_synchronize.
-      # This only synchronizes IFF in :auto mode, i.e. the user has not explicitly disabled automatic syncing.
-      # The :auto mode has nothing to do with the { lazy } option.
-      def auto_synchronize(**options)
-        if mode == :auto
-          synchronize(**options)
-        end
-      end
-
-      private
-
-      def synchronize_now(log: 'Synchronizing')
-        self.synchronizing = true
-        self.synchronized = false
-
-        self.log(log)
-
-        start_time = current_seconds
+        will_synchronize_client = !(lazy && client.synchronized?)
 
         begin
-          with_max_wait_time(timeout) do
-            message_from_js = evaluate_async_script(<<~JS)
-              let done = arguments[0]
-              let synchronize = () => {
-                if (window.CapybaraLockstep) {
-                  CapybaraLockstep.synchronize(done)
-                } else {
-                  done(#{ERROR_SNIPPET_MISSING.to_json})
-                }
-              }
-              const emptyDataURL = /^data:[^,]*,?$/
-              if (emptyDataURL.test(location.href) || location.protocol === 'about:') {
-                done(#{ERROR_PAGE_MISSING.to_json})
-              } else if (document.readyState === 'complete') {
-                // WebDriver always waits for the `load` event after a visit(),
-                // unless a different page load strategy was configured.
-                synchronize()
-              } else {
-                window.addEventListener('load', synchronize)
-              }
-            JS
-
-            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
-              end_time = current_seconds
-              ms_elapsed = ((end_time.to_f - start_time) * 1000).round
-              log "Synchronized successfully [#{ms_elapsed} ms]"
-              self.synchronized = true
-            end
-          end
-        rescue ::Selenium::WebDriver::Error::ScriptTimeoutError
-          timeout_message = "Could not synchronize within #{timeout} seconds"
-          log timeout_message
-          if timeout_with == :error
-            raise Timeout, timeout_message
-          else
-            # Don't raise an error, this may happen if the server is slow to respond.
-            # We will retry on the next Capybara synchronize call.
+          # Synchronizing the server is free, so we ignore { lazy } and do it every time.
+          server.synchronize
+
+          if will_synchronize_client
+            self.log(log)
+            self.synchronizing = true
+            client.synchronize
+            # Synchronizing the server is free, so we ignore { lazy } and do it every time.
+            server.synchronize
           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
 
-      ensure
-        self.synchronizing = false
-      end
-
-      def unhandled_synchronize_error(e)
-        log "#{e.class.name} while synchronizing: #{e.message}"
-        raise e
-      end
-
-      def page
-        Capybara.current_session
-      end
-
-      delegate :evaluate_script, :evaluate_async_script, :execute_script, :driver, to: :page
-
-      def with_max_wait_time(seconds, &block)
-        old_max_wait_time = Capybara.default_max_wait_time
-        Capybara.default_max_wait_time = seconds
-        begin
-          block.call
-        ensure
-          Capybara.default_max_wait_time = old_max_wait_time
+        if will_synchronize_client
+          run_after_synchronize_callbacks
         end
       end
 
-      def ignoring_alerts(&block)
-        block.call
-      rescue ::Selenium::WebDriver::Error::UnexpectedAlertOpenError
-        # no-op
+      delegate :start_work, :stop_work, to: :server
+
+      def server
+        @server ||= Server.new
       end
 
-      def current_seconds
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      def client
+        @client ||= Client.new
       end
 
     end
-
   end
 end
-

data/lib/capybara-lockstep/logging.rb

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

data/lib/capybara-lockstep/middleware.rb

@@ -0,0 +1,22 @@
+module Capybara
+  module Lockstep
+    class Middleware
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        tag = "Server request for #{env['PATH_INFO'] || 'unknown path'}"
+        Lockstep.start_work(tag)
+
+        begin
+          @app.call(env)
+        ensure
+          Lockstep.stop_work(tag)
+        end
+      end
+
+    end
+  end
+end

data/lib/capybara-lockstep/page_access.rb

@@ -0,0 +1,28 @@
+module Capybara
+  module Lockstep
+    module PageAccess
+      def page
+        Capybara.current_session
+      end
+
+      delegate :evaluate_script, :evaluate_async_script, :execute_script, :driver, to: :page
+
+      def javascript_driver?
+        driver.is_a?(Capybara::Selenium::Driver)
+      end
+
+      def alert_present?
+        # Chrome 54 and/or Chromedriver 2.24 introduced a breaking change on how
+        # accessing browser logs work.
+        #
+        # Apparently, while an alert/confirm is open, Chrome will block any requests
+        # to its `getLog` API. This causes Selenium to time out with a `Net::ReadTimeout` error
+        page.driver.browser.switch_to.alert
+        true
+      rescue Capybara::NotSupportedByDriverError, ::Selenium::WebDriver::Error::NoSuchAlertError
+        false
+      end
+
+    end
+  end
+end

data/lib/capybara-lockstep/server.rb

@@ -0,0 +1,46 @@
+module Capybara
+  module Lockstep
+    class Server
+      include Logging
+
+      def initialize
+        @job_count = 0
+        @job_count_mutex = Mutex.new
+        @idle_condition = ConditionVariable.new
+      end
+
+      attr_accessor :job_count
+
+      def start_work(tag)
+        job_count_mutex.synchronize do
+          self.job_count += 1
+          log("Started server work: #{tag} [#{job_count} server jobs]") if tag
+        end
+      end
+
+      def stop_work(tag)
+        job_count_mutex.synchronize do
+          self.job_count -= 1
+          log("Stopped server work: #{tag} [#{job_count} server jobs]") if tag
+
+          if job_count == 0
+            idle_condition.broadcast
+          end
+        end
+      end
+
+      def synchronize
+        job_count_mutex.synchronize do
+          if job_count > 0
+            idle_condition.wait(job_count_mutex)
+          end
+        end
+      end
+
+      private
+
+      attr_reader :job_count_mutex, :idle_condition
+
+    end
+  end
+end

data/lib/capybara-lockstep/util.rb

@@ -0,0 +1,21 @@
+module Capybara
+  module Lockstep
+    module Util
+      class << self
+        def with_max_wait_time(seconds, &block)
+          old_max_wait_time = Capybara.default_max_wait_time
+          Capybara.default_max_wait_time = seconds
+          begin
+            block.call
+          ensure
+            Capybara.default_max_wait_time = old_max_wait_time
+          end
+        end
+
+        def current_seconds
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+      end
+    end
+  end
+end

data/lib/capybara-lockstep/version.rb

@@ -1,5 +1,5 @@
 module Capybara
   module Lockstep
-    VERSION = "1.3.1"
+    VERSION = "2.0.0.rc1"
   end
 end

data/lib/capybara-lockstep.rb

@@ -10,8 +10,13 @@ end
 
 require_relative 'capybara-lockstep/version'
 require_relative 'capybara-lockstep/errors'
+require_relative 'capybara-lockstep/util'
 require_relative 'capybara-lockstep/configuration'
 require_relative 'capybara-lockstep/logging'
+require_relative 'capybara-lockstep/page_access'
 require_relative 'capybara-lockstep/lockstep'
 require_relative 'capybara-lockstep/capybara_ext'
 require_relative 'capybara-lockstep/helper'
+require_relative 'capybara-lockstep/server'
+require_relative 'capybara-lockstep/client'
+require_relative 'capybara-lockstep/middleware'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: capybara-lockstep
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 2.0.0.rc1
 platform: ruby
 authors:
 - Henning Koch
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-10-25 00:00:00.000000000 Z
+date: 2023-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capybara
@@ -88,12 +88,17 @@ files:
 - capybara-lockstep.gemspec
 - lib/capybara-lockstep.rb
 - lib/capybara-lockstep/capybara_ext.rb
+- lib/capybara-lockstep/client.rb
 - lib/capybara-lockstep/configuration.rb
 - lib/capybara-lockstep/errors.rb
 - lib/capybara-lockstep/helper.js
 - lib/capybara-lockstep/helper.rb
 - lib/capybara-lockstep/lockstep.rb
 - lib/capybara-lockstep/logging.rb
+- lib/capybara-lockstep/middleware.rb
+- lib/capybara-lockstep/page_access.rb
+- lib/capybara-lockstep/server.rb
+- lib/capybara-lockstep/util.rb
 - lib/capybara-lockstep/version.rb
 homepage: https://github.com/makandra/capybara-lockstep
 licenses:
@@ -115,9 +120,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.4.3
 signing_key: