capybara-lockstep 1.1.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ece5e0daeb6883b02791ed06f6ff2afca446e5aa5635f22d3ec5b94d0e96aa7
-  data.tar.gz: 5e4d53a8c59f71071aa48fee8ec87fa62e5c189e026b5cac563fd9427a082c59
+  metadata.gz: e9207a7671ab6f25999a138df922afb783ec3267257eadfab1b179f3c26eb88d
+  data.tar.gz: 2ddfe3a9a10143894afdc2eb2517ddeeaf76311e3365693606359282004a598d
 SHA512:
-  metadata.gz: 7e68bf91ab8b5ecf91b145159697e7990dbbbb3a5497955d50d91ea83d802c50195f803ae1fd029b2b76dc18b407bd1995b03aa292e30873cd35f8746dfa509e
-  data.tar.gz: 8fb8d9b19fc47b5769208d36125b6cc2fb40375a8d5b46216ec318a3fd8459ca26f6bf22f352efcf350b7d7cbfe89f7bb866633fb4e096812b7d31513d4c7bae
+  metadata.gz: dffa87e401d189b8afea6bb72b49bb14a6f9865d306fc7a838e50b4fb4dfc715fe8930502b9e3e2b4139c214b45eefe189c0ddb8e3e867d30d3021331ba76ea3
+  data.tar.gz: b311ee487b65ae42dc5dcc114cdd2aca2ff39ed49953fe43959ecf8578b3691740ebd2019aeae95fc87334cc5b87835f18b1f816ed2ad0a234e6475b549baad8

data/CHANGELOG.md

@@ -2,6 +2,48 @@ 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).
 
+
+## 1.2.1 - 2022-09-12
+
+- Synchronize with pages constructed from non-empty [data URLs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs)
+
+## 1.2.0 - 2022-09-12
+
+### Synchronization around history navigation
+
+We now synchronize before and after history navigation using the following Capybara methods:
+
+- `page.refresh`
+- `page.go_back`
+- `page.go_forward`
+
+We also synchronize before `current_url` in case running a JavaScript task wants to update the URL when done.
+
+### Support for tests with multiple tabs or frames
+
+capybara-lockstep now supports test that work with [multiple frames](https://makandracards.com/makandra/34015-use-capybara-commands-inside-an-iframe) or [multiple tabs or windows](https://github.com/teamcapybara/capybara#working-with-windows).
+We now synchronize before and after the following Capybara methods:
+
+- `switch_to_frame`
+- `within_frame`
+- `switch_to_window`
+- `within_window`
+
+### Improved logging
+
+- Only log when we're actually synchronizing
+- Log the reason why we're synchronizing (e.g. before node access)
+- Log which browser work we're waiting for (e.g. XHR request, image load)
+
+### Various changes
+
+- Synchronize before accessing `page.html`.
+
+
+## 1.1.1 - 2022-03-16
+
+- Activate rubygems MFA
+
 ## 1.1.0
 
 - Stop handling of `[data-initializing]` attribute. Apps that have late initialization after the `load` event can just use `CapybaraLockstep.startWork()`.

data/Gemfile

@@ -14,3 +14,5 @@ gem 'chrome_remote'
 
 gem 'byebug'
 gem 'gemika'
+
+gem 'activesupport', '~> 6.0'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    capybara-lockstep (1.1.0)
+    capybara-lockstep (1.2.1)
       activesupport (>= 3.2)
       capybara (>= 2.0)
       ruby2_keywords
@@ -10,32 +10,33 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.1.3.1)
+    activesupport (6.1.7)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
       zeitwerk (~> 2.3)
-    addressable (2.7.0)
-      public_suffix (>= 2.0.2, < 5.0)
+    addressable (2.8.1)
+      public_suffix (>= 2.0.2, < 6.0)
     byebug (11.1.3)
-    capybara (3.35.3)
+    capybara (3.37.1)
       addressable
+      matrix
       mini_mime (>= 0.1.3)
       nokogiri (~> 1.8)
       rack (>= 1.6.0)
       rack-test (>= 0.6.3)
       regexp_parser (>= 1.5, < 3.0)
       xpath (~> 3.2)
-    childprocess (3.0.0)
+    childprocess (4.1.0)
     chrome_remote (0.3.0)
       websocket-driver (~> 0.6)
-    concurrent-ruby (1.1.8)
+    concurrent-ruby (1.1.10)
     daemons (1.3.1)
     diff-lcs (1.3)
     eventmachine (1.2.7)
     gemika (0.6.0)
-    i18n (1.8.10)
+    i18n (1.12.0)
       concurrent-ruby (~> 1.0)
     jasmine (3.6.0)
       jasmine-core (~> 3.6.0)
@@ -43,18 +44,20 @@ GEM
       rack (>= 1.2.1)
       rake
     jasmine-core (3.6.0)
-    mini_mime (1.1.0)
-    minitest (5.14.4)
-    nokogiri (1.11.3-x86_64-linux)
+    matrix (0.4.2)
+    mini_mime (1.1.2)
+    minitest (5.16.3)
+    nokogiri (1.13.8-x86_64-linux)
       racc (~> 1.4)
     phantomjs (2.1.1.0)
-    public_suffix (4.0.6)
-    racc (1.5.2)
+    public_suffix (5.0.0)
+    racc (1.6.0)
     rack (2.2.3)
-    rack-test (1.1.0)
-      rack (>= 1.0, < 3)
+    rack-test (2.0.2)
+      rack (>= 1.3)
     rake (13.0.1)
-    regexp_parser (2.1.1)
+    regexp_parser (2.5.0)
+    rexml (3.2.5)
     rspec (3.7.0)
       rspec-core (~> 3.7.0)
       rspec-expectations (~> 3.7.0)
@@ -68,28 +71,32 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.7.0)
     rspec-support (3.7.0)
-    ruby2_keywords (0.0.4)
-    rubyzip (2.3.0)
-    selenium-webdriver (3.142.7)
-      childprocess (>= 0.5, < 4.0)
-      rubyzip (>= 1.2.2)
+    ruby2_keywords (0.0.5)
+    rubyzip (2.3.2)
+    selenium-webdriver (4.4.0)
+      childprocess (>= 0.5, < 5.0)
+      rexml (~> 3.2, >= 3.2.5)
+      rubyzip (>= 1.2.2, < 3.0)
+      websocket (~> 1.0)
     thin (1.8.0)
       daemons (~> 1.0, >= 1.0.9)
       eventmachine (~> 1.0, >= 1.0.4)
       rack (>= 1, < 3)
-    tzinfo (2.0.4)
+    tzinfo (2.0.5)
       concurrent-ruby (~> 1.0)
+    websocket (1.2.9)
     websocket-driver (0.7.3)
       websocket-extensions (>= 0.1.0)
     websocket-extensions (0.1.5)
     xpath (3.2.0)
       nokogiri (~> 1.8)
-    zeitwerk (2.4.2)
+    zeitwerk (2.6.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  activesupport (~> 6.0)
   byebug
   capybara-lockstep!
   chrome_remote
@@ -100,4 +107,4 @@ DEPENDENCIES
   thin
 
 BUNDLED WITH
-   2.2.15
+   2.2.32

data/README.md

@@ -58,11 +58,17 @@ How capybara-lockstep helps
 
 capybara-lockstep waits until the browser is idle before moving on to the next Capybara command. This greatly relieves the pressure on [Capybara's retry logic](https://github.com/teamcapybara/capybara#asynchronous-javascript-ajax-and-friends).
 
-Before Capybara simulates a user interaction (clicking, typing, etc.) or before it visits a new URL:
+capybara-lockstep synchronizes before:
 
-- capybara-lockstep waits for all document resources to load (images, CSS, fonts, frames).
-- capybara-lockstep waits for any AJAX requests to finish.
-- capybara-lockstep waits for client-side JavaScript to render or hydrate DOM elements.
+- Capybara simulates a user interaction (clicking, typing, etc.)
+- Capybara visits a new URL
+- Capybara executes JavaScript
+
+When capybara-lockstep synchronizes it will:
+
+- wait for all document resources to load (images, CSS, fonts, frames).
+- wait for client-side JavaScript to render or hydrate DOM elements.
+- wait for any pending AJAX requests to finish and their callbacks to be called.
 - capybara-lockstep waits for dynamically inserted `<script>`s to load (e.g. from [dynamic imports](https://webpack.js.org/guides/code-splitting/#dynamic-imports) or Analytics snippets).
 - capybara-lockstep waits for dynamically inserted `<img>` or `<iframe>` elements to load.
 
@@ -111,7 +117,7 @@ capybara-lockstep requires a JavaScript snippet to be embedded by the applicatio
 **If you're using Rails** you can use the `capybara_lockstep` helper to insert the snippet into your application layouts:
 
 ```erb
-<%= capybara_lockstep if Rails.env.test? %>
+<%= capybara_lockstep if defined?(Capybara::Lockstep) %>
 ```
 
 Ideally the snippet should be included in the `<head>` before any other `<script>` tags.
@@ -146,22 +152,24 @@ Note that you may see some failures from tests with wrong assertions, which prev
 
 ## Signaling asynchronous work
 
-By default capybara-lockstep blocks all async work that 
+By default capybara-lockstep waits until resources have loaded, AJAX requests have finished and their callbacks have been called.
 
-If for some reason you want capybara-lockstep to consider additional asynchronous work as "busy", you can do so:
+You can configure capybara-lockstep to wait for other async work that does not involve the network. Let's say we have an animation that fades in a new element over 2 seconds. The following will prevent Capybara from observing the page while the animation is running:
 
 ```js
-CapybaraLockstep.startWork('Eject warp core')
-doAsynchronousWork().then(function() {
-  CapybaraLockstep.stopWork('Eject warp core')
-})
+async function fadeIn(element) {
+  CapybaraLockstep.startWork('Animation')
+  startAnimation(element, 'fade-in')
+  await waitForAnimationEnd(element)
+  CapybaraLockstep.stopWork('Animation')
+}
 ```
 
 The string argument is used for logging (when logging is enabled). It does **not** need to be unique per job. In this case you should see messages like this in your browser's JavaScript console:
 
 ```text
-[capybara-lockstep] Started work: Eject warp core [1 jobs]
-[capybara-lockstep] Finished work: Eject warp core [0 jobs]
+[capybara-lockstep] Started work: Animation [1 jobs]
+[capybara-lockstep] Finished work: Animation [0 jobs]
 ```
 
 You may omit the string argument, in which case nothing will be logged, but the work will still be tracked.
@@ -177,6 +185,12 @@ if (window.CapybaraLockstep) {
 }
 ```
 
+If you can use ES6 you may also use [optional chaining](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining) to only call a function if `window.CapybaraLockstep` is defined:
+
+```js
+window.CapybaraLockstep?.startWork('Work')
+```
+
 
 ## Performance impact
 
@@ -295,7 +309,7 @@ end
 
 In the `:manual` mode you may still force synchronization by calling `Capybara::Lockstep.synchronize` manually.
 
-To completely disable synchronization:
+To completely disable synchronization, even when `Capybara::Lockstep.synchronize` is called:
 
 ```ruby
 Capybara::Lockstep.mode = :off
@@ -306,25 +320,29 @@ Capybara::Lockstep.synchronize # will not synchronize
 
 ## Handling legacy promises
 
-Legacy promise implementations (like jQuery's `$.Deferred` and AngularJS' `$q`) work using tasks instead of microtasks. Their AJAX implementations (like `$.ajax()` and `$http`) use these promises to signal that a request is done.
+Legacy promise implementations (like jQuery's `$.Deferred` and AngularJS' `$q`) work using [tasks instead of microtasks](https://jakearchibald.com/2015/tasks-microtasks-queues-and-schedules/). Their AJAX implementations (like `$.ajax()` and `$http`) use task-based promises to signal that a request is done.
 
 This means there is a time window in which all AJAX requests have finished, but their callbacks have not yet run:
 
 ```js
-$.ajax('/foo').then(function() {
+$http.get('/foo').then(function() {
   // This callback runs one task after the response was received
 })
 ```
 
-It is theoretically possible that your test will observe the browser in that window, and expect content that has not been rendered yet. This will usually be mitigated by Capybara's retry logic. **If** you think that this is an issue for your test suite, you can configure capybara-headless to wait additional tasks before it considers the browser to be idle:
+It is theoretically possible that your test will observe the browser in that window, and expect content that has not been rendered yet. Affected code must call `then()` on a task-based promise **or** use `setTimeout()` to push work into the next task.
 
-```js
-Capybara:Lockstep.wait_tasks = 1
+Any issues caused by this will usually be mitigated by Capybara's retry logic. **If** you think that this is an issue for your test suite, you can configure capybara-headless to wait additional tasks before it considers the browser to be idle:
+
+```ruby
+Capybara::Lockstep.wait_tasks = 1
 ```
 
-If you see longer `then()` chains in your code, you may need to configure a higher number of tasks to wait.
+If you see longer chains of `then()` or nested `setTimeout()` calls in your code, you may need to configure a higher number of tasks to wait.
+
+Waiting additional tasks will have a negative performance impact on your test suite.
 
-This will have a negative performance impact on your test suite.
+> **Note:** When capybara-lockstep detects jQuery on the page, it will automatically patch [`$.ajax()`](https://api.jquery.com/jQuery.ajax/) to wait an additional task after the response was received. If your only concern is callbacks to `$.ajax()` you do not need so set `Capybara::Lockstep.wait_tasks`.
 
 
 ## Contributing

data/capybara-lockstep.gemspec

@@ -14,6 +14,10 @@ Gem::Specification.new do |spec|
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
 
+  spec.metadata["bug_tracker_uri"] = "https://github.com/makandra/capybara-lockstep/issues"
+  spec.metadata["changelog_uri"] = "https://github.com/makandra/capybara-lockstep/blob/master/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = 'true'
+
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do

data/lib/capybara-lockstep/capybara_ext.rb

@@ -1,34 +1,99 @@
 require 'ruby2_keywords'
 
+module Capybara
+  module Lockstep
+    module UnsychronizeAfter
+      def unsychronize_after(meth)
+        mod = Module.new do
+          define_method meth do |*args, &block|
+            super(*args, &block)
+          ensure
+            Lockstep.synchronized = false
+          end
+
+          ruby2_keywords meth
+        end
+
+        prepend(mod)
+      end
+    end
+  end
+end
+
+module Capybara
+  module Lockstep
+    module SynchronizeBefore
+      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
+    end
+  end
+end
+
+Capybara::Session.class_eval do
+  extend Capybara::Lockstep::SynchronizeBefore
+  extend Capybara::Lockstep::UnsychronizeAfter
+
+  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
+
+  synchronize_before :go_back, lazy: false # wait until running JavaScript has updated the URL
+  unsychronize_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
+
+  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.
+
+  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.
+end
+
 module Capybara
   module Lockstep
     module VisitWithWaiting
-      ruby2_keywords def visit(*args, &block)
+      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:'))
+        visiting_real_url = !(url.start_with?('data:') || url.start_with?('about:'))
 
-        if visiting_remote_url
+        if visiting_real_url
           # We're about to leave this screen, killing all in-flight requests.
           # Give pending form submissions etc. a chance to finish before we tear down
           # the browser environment.
           #
           # We force a non-lazy synchronization so we pick up all client-side changes
           # that have not been caused by Capybara commands.
-          Lockstep.synchronize(lazy: false)
+          Lockstep.auto_synchronize(lazy: false, log: "Synchronizing before visiting #{url}")
         end
 
         super(*args, &block).tap do
-          if visiting_remote_url
+          if visiting_real_url
             # We haven't yet synchronized the new screen.
             Lockstep.synchronized = false
           end
         end
       end
+
+      ruby2_keywords :visit
     end
   end
 end
@@ -58,14 +123,15 @@ module Capybara
               Lockstep.auto_synchronize(lazy: !script_may_navigate_away, log: "Synchronizing before script: #{script}")
             end
 
-            super(script, *args, &block).tap do
-              if !Lockstep.synchronizing?
-                # We haven't yet synchronized with whatever changes the JavaScript
-                # did on the frontend.
-                Lockstep.synchronized = false
-              end
+            super(script, *args, &block)
+          ensure
+            if !Lockstep.synchronizing?
+              # We haven't yet synchronized with whatever changes the JavaScript
+              # did on the frontend.
+              Lockstep.synchronized = false
             end
           end
+
           ruby2_keywords meth
         end
         prepend(mod)
@@ -84,24 +150,6 @@ Capybara::Session.class_eval do
   # internally and we don't want to synchronize multiple times.
 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
-              Lockstep.synchronized = false
-            end
-          end
-          ruby2_keywords meth
-        end
-        prepend(mod)
-      end
-    end
-  end
-end
-
 # Capybara 3 has driver-specific Node classes which sometimes
 # super to Capybara::Selenium::Node, but not always.
 node_classes = [
@@ -141,14 +189,16 @@ end
 module Capybara
   module Lockstep
     module SynchronizeWithCatchUp
-      ruby2_keywords def synchronize(*args, &block)
+      def synchronize(*args, &block)
         # This method is called by Capybara before most interactions with
         # the browser. It is a different method than Capybara::Lockstep.synchronize!
         # We use the { lazy } option to only synchronize when we're out of sync.
-        Capybara::Lockstep.auto_synchronize(lazy: true)
+        Lockstep.auto_synchronize(lazy: true, log: 'Synchronizing before node access')
 
         super(*args, &block)
       end
+
+      ruby2_keywords :synchronize
     end
   end
 end

data/lib/capybara-lockstep/helper.js

@@ -3,12 +3,14 @@ window.CapybaraLockstep = (function() {
   let debug
   let jobCount
   let idleCallbacks
+  let finishedWorkTags
   let waitTasks
   reset()
 
   function reset() {
     jobCount = 0
     idleCallbacks = []
+    finishedWorkTags = []
     waitTasks = 0
     debug = false
   }
@@ -74,12 +76,17 @@ window.CapybaraLockstep = (function() {
     jobCount--
 
     if (tag) {
+      finishedWorkTags.push(tag)
       logPositive('Finished work: %s [%d jobs]', tag, jobCount)
     }
 
-    let idleCallback
-    while (isIdle() && (idleCallback = idleCallbacks.shift())) {
-      idleCallback('Finished waiting for browser')
+    if (isIdle()) {
+      let idleCallback
+      while ((idleCallback = idleCallbacks.shift())) {
+        idleCallback("Finished waiting for " + finishedWorkTags.join(', '))
+      }
+
+      finishedWorkTags = []
     }
   }
 

data/lib/capybara-lockstep/lockstep.rb

@@ -1,7 +1,7 @@
 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_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"
 
@@ -13,7 +13,17 @@ module Capybara
       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
@@ -24,19 +34,30 @@ module Capybara
       end
 
       def synchronize(lazy: false, log: nil)
+        # 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.
+        #
+        # With { lazy: true } we only synchronize when the Ruby-side thinks we're out of sync.
+        # This saves us an expensive execute_script() roundtrip that goes to the browser and back.
+        # However the knowledge of the Ruby-side is limited: We only assume that we're out of sync
+        # after a page load or after a Capybara command. There may be additional client-side work
+        # that the Ruby-side is not aware of, e.g. an AJAX call scheduled by a timeout.
+        #
+        # With { lazy: false } we force synchronization with the browser, whether the Ruby-side
+        # 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
 
-        # Allow passing a log message that is only logged
-        # when we're actually synchronizing.
-        if log
-          self.log(log)
-        end
-
-        synchronize_now
+        synchronize_now(log: log)
       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)
@@ -45,11 +66,11 @@ module Capybara
 
       private
 
-      def synchronize_now
+      def synchronize_now(log: 'Synchronizing')
         self.synchronizing = true
         self.synchronized = false
 
-        log 'Synchronizing'
+        self.log(log)
 
         start_time = current_seconds
 
@@ -64,8 +85,8 @@ module Capybara
                   done(#{ERROR_SNIPPET_MISSING.to_json})
                 }
               }
-              let protocol = location.protocol
-              if (protocol === 'data:' || protocol == 'about:') {
+              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(),

data/lib/capybara-lockstep/version.rb

@@ -1,5 +1,5 @@
 module Capybara
   module Lockstep
-    VERSION = "1.1.0"
+    VERSION = "1.2.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: capybara-lockstep
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Henning Koch
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-07-08 00:00:00.000000000 Z
+date: 2022-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capybara
@@ -101,6 +101,9 @@ licenses:
 metadata:
   homepage_uri: https://github.com/makandra/capybara-lockstep
   source_code_uri: https://github.com/makandra/capybara-lockstep
+  bug_tracker_uri: https://github.com/makandra/capybara-lockstep/issues
+  changelog_uri: https://github.com/makandra/capybara-lockstep/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths: