async-webdriver 0.8.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c3dae5c334d2b97f044519b5c4235c104148fadcac0e95f25764551197a889c
-  data.tar.gz: b843c0e5eca27f7382d9d972fdce259051607c844600eea887a82e4a81d5e167
+  metadata.gz: 7d44f03f80dc5674a12fabaeb89138fb2edc8d4aa240644a554d12edd9b70686
+  data.tar.gz: '07129f8f6173caebca9e23629018ceec2299c5093e5eea9bec252ad4641f0b1f'
 SHA512:
-  metadata.gz: 39488968a35e04975b8f1bfe8d2287dac5811f4a6e32db4a52dc14c835d43b0b502285d0e88f7925f1b0776610ec3011901a575dee56af5755101fface01d44c
-  data.tar.gz: '082e3d764d278351a50cf7bc969d586a94ee26a0066314f9de3577189dd752cb54eb0eaecc8fe1d9b4aadef1627c0df6b8eb7829702aa9cbc7e8a27b2281944b'
+  metadata.gz: 729f7b01d41bae86173a3b0c26b7741ebae3ba3254da57c4d1583eb50c4564d1b1eace54bcf54b0f1c993f761e960d4ddaeda4389bb26dfe2255fcafb0885f9a
+  data.tar.gz: bb089d62cdf93ddf7db5799e1d64f7f97c7819b8272694d0c657bf1a3f990bd5f247677d38b631111df99576f290b14507de3f3cc9f4ce8150050b0be7357b3a

data/context/debugging.md

@@ -0,0 +1,252 @@
+# Debugging
+
+This guide explains how to debug WebDriver issues by capturing HTML source and screenshots when tests fail.
+
+## Overview
+
+When WebDriver tests fail, it's often helpful to capture the current state of the page to understand what went wrong. The most useful debugging artifacts are:
+
+- **HTML Source**: Shows the current DOM structure, helpful for understanding why element selectors might be failing
+- **Screenshots**: Provides a visual representation of what the browser is actually showing
+
+## Core Concepts
+
+`async-webdriver` provides built-in methods for capturing debugging information:
+
+- {ruby Async::WebDriver::Session#document_source} returns the HTML source of the current page.
+- {ruby Async::WebDriver::Session#screenshot} captures a screenshot of the entire page.
+- {ruby Async::WebDriver::Element#screenshot} captures a screenshot of a specific element.
+
+## Basic Debugging
+
+### Capturing HTML Source
+
+To save the current page HTML to a file:
+
+```ruby
+require "async/webdriver"
+
+Async::WebDriver::Bridge::Pool.open do |pool|
+	pool.session do |session|
+		session.visit("https://example.com")
+		
+		# Save HTML source for debugging
+		html = session.document_source
+		File.write("debug.html", html)
+		
+		puts "HTML saved to debug.html"
+	end
+end
+```
+
+### Capturing Screenshots
+
+To save a screenshot of the current page:
+
+```ruby
+require "async/webdriver"
+
+Async::WebDriver::Bridge::Pool.open do |pool|
+	pool.session do |session|
+		session.visit("https://example.com")
+		
+		# Take a screenshot (returns PNG binary data)
+		screenshot_data = session.screenshot
+		File.binwrite("debug.png", screenshot_data)
+		
+		puts "Screenshot saved to debug.png"
+	end
+end
+```
+
+### Element Screenshots
+
+To capture a screenshot of a specific element:
+
+```ruby
+require "async/webdriver"
+
+Async::WebDriver::Bridge::Pool.open do |pool|
+	pool.session do |session|
+		session.visit("https://example.com")
+		
+		# Find an element and screenshot it
+		element = session.find_element_by_tag_name("body")
+		element_screenshot = element.screenshot
+		File.binwrite("element-debug.png", element_screenshot)
+		
+		puts "Element screenshot saved to element-debug.png"
+	end
+end
+```
+
+## Debugging Failed Element Searches
+
+A common debugging scenario is when `find_element` fails. Here's how to capture debugging information:
+
+```ruby
+require "async/webdriver"
+
+def debug_element_search(session, locator_type, locator_value)
+	begin
+		# Use the correct locator format for async-webdriver
+		locator = {using: locator_type, value: locator_value}
+		element = session.find_element(locator)
+		puts "✅ Element found: #{locator_type}=#{locator_value}"
+		return element
+	rescue Async::WebDriver::NoSuchElementError => e
+		puts "❌ Element not found: #{locator_type}=#{locator_value}"
+		
+		# Capture debugging information
+		timestamp = Time.now.strftime("%Y%m%d-%H%M%S")
+		
+		# Save HTML source
+		html = session.document_source
+		html_file = "debug-#{timestamp}.html"
+		File.write(html_file, html)
+		puts "📄 HTML saved to #{html_file}"
+		
+		# Save screenshot
+		screenshot_data = session.screenshot
+		screenshot_file = "debug-#{timestamp}.png"
+		File.binwrite(screenshot_file, screenshot_data)
+		puts "📸 Screenshot saved to #{screenshot_file}"
+		
+		# Re-raise the original error
+		raise e
+	end
+end
+
+# Usage example
+Async::WebDriver::Bridge::Pool.open do |pool|
+	pool.session do |session|
+		session.visit("https://example.com")
+		
+		# This will save debug files if the element isn't found
+		button = debug_element_search(session, "id", "submit-button")
+	end
+end
+```
+
+## Advanced Debugging Techniques
+
+### Configuring Timeouts for Debugging
+
+WebDriver uses different timeout settings that affect how long operations wait:
+
+```ruby
+require "async/webdriver"
+
+Async::WebDriver::Bridge::Pool.open do |pool|
+	pool.session do |session|
+		# Configure timeouts for debugging (values in milliseconds)
+		session.implicit_wait_timeout = 10_000  # 10 seconds for element finding
+		session.page_load_timeout = 30_000      # 30 seconds for page loads
+		session.script_timeout = 5_000          # 5 seconds for JavaScript execution
+		
+		puts "Current timeouts: #{session.timeouts}"
+		
+		# Now element finding will wait up to 10 seconds
+		session.visit("https://example.com")
+		element = session.find_element(:id, "dynamic-content")  # Will wait up to 10s
+	end
+end
+```
+
+### Wait and Debug Pattern
+
+Sometimes elements appear after a delay. Here's how to debug timing issues:
+
+```ruby
+require "async/webdriver"
+
+def wait_and_debug(session, locator_type, locator_value, timeout: 10000)
+	# Set implicit wait timeout (in milliseconds)
+	original_timeout = session.implicit_wait_timeout
+	session.implicit_wait_timeout = timeout
+	
+	start_time = Time.now
+	
+	begin
+		# Try to find the element (will use implicit wait timeout)
+		locator = {using: locator_type, value: locator_value}
+		session.find_element(locator)
+	rescue Async::WebDriver::NoSuchElementError => error
+		elapsed = Time.now - start_time
+		puts "⏰ Timeout after #{elapsed.round(2)}s waiting for #{locator_type}=#{locator_value}"
+		
+		# Capture final state
+		timestamp = Time.now.strftime("%Y%m%d-%H%M%S")
+		
+		html = session.document_source
+		File.write("timeout-debug-#{timestamp}.html", html)
+		
+		screenshot_data = session.screenshot
+		File.binwrite("timeout-debug-#{timestamp}.png", screenshot_data)
+		
+		puts "📄 Final HTML saved to timeout-debug-#{timestamp}.html"
+		puts "📸 Final screenshot saved to timeout-debug-#{timestamp}.png"
+		
+		raise
+	ensure
+		# Restore original timeout
+		session.implicit_wait_timeout = original_timeout
+	end
+end
+```
+
+### Multi-Step Debugging
+
+For complex test scenarios, capture state at multiple points:
+
+```ruby
+require "async/webdriver"
+
+class DebugHelper
+	def initialize(test_name)
+		@test_name = test_name
+		@step = 0
+	end
+	
+	def capture_state(session, description)
+		@step += 1
+		timestamp = Time.now.strftime("%Y%m%d-%H%M%S")
+		prefix = "#{@test_name}-step#{@step}-#{timestamp}"
+		
+		# Save HTML
+		html = session.document_source
+		html_file = "#{prefix}-#{description}.html"
+		File.write(html_file, html)
+		
+		# Save screenshot
+		screenshot_data = session.screenshot
+		screenshot_file = "#{prefix}-#{description}.png"
+		File.binwrite(screenshot_file, screenshot_data)
+		
+		puts "🔍 Step #{@step}: #{description}"
+		puts "   📄 #{html_file}"
+		puts "   📸 #{screenshot_file}"
+	end
+end
+
+# Usage example
+debug = DebugHelper.new("login-test")
+
+Async::WebDriver::Bridge::Pool.open do |pool|
+	pool.session do |session|
+		debug.capture_state(session, "initial-page")
+		
+		session.visit("https://example.com/login")
+		debug.capture_state(session, "login-page-loaded")
+		
+		session.find_element_by_id("username").send_keys("user@example.com")
+		debug.capture_state(session, "username-entered")
+		
+		session.find_element_by_id("password").send_keys("password")
+		debug.capture_state(session, "password-entered")
+		
+		session.find_element_by_id("submit").click
+		debug.capture_state(session, "form-submitted")
+	end
+end
+```

data/context/getting-started.md

@@ -0,0 +1,90 @@
+# Getting Started
+
+This guide explains how to use `async-webdriver` for controlling a browser.
+
+## Installation
+
+Add the gem to your project:
+
+~~~ bash
+$ bundle add async-webdriver
+~~~
+
+## Core Concepts
+
+`async-webdriver` is a Ruby implementation of the [WebDriver](https://www.w3.org/TR/webdriver/) protocol. It allows you to control a browser from Ruby code. It is built on top of [async](https://github.com/socketry/async) and [async-http](https://github.com/socketry/async-http). It has several core concepts:
+
+- A {ruby Async::WebDriver::Bridge} can be used to start a web driver process, e.g. `chromedriver`, `geckodriver`, etc. It can be used in isolation, or not at all.
+- A {ruby Async::WebDriver::Client} is used to connect to a running web driver and can be used to create new sessions.
+- A {ruby Async::WebDriver::Session} represents a single browser session. It is used to control a browser window and navigate to different pages.
+- A {ruby Async::WebDriver::Element} represents a single element on a page. It can be used to interact with the element, e.g. click, type, etc.
+
+## Basic Usage
+
+The following example shows how to use `async-webdriver` to open a browser, navigate to a page, and click a button:
+
+~~~ ruby
+require 'async/webdriver'
+
+Async do
+	bridge = Async::WebDriver::Bridge::Chrome.new(headless: false)
+	
+	driver = bridge.start
+	client = Async::WebDriver::Client.open(driver.endpoint)
+	
+	session = client.session(bridge.default_capabilities)
+	# Set the implicit wait timeout to 10 seconds since we are dealing with the real internet (which can be slow):
+	session.implicit_wait_timeout = 10_000
+	
+	session.visit('https://google.com')
+	
+	session.fill_in('q', 'async-webdriver')
+	session.click_button("I'm Feeling Lucky")
+	
+	puts session.document_title
+ensure
+	session&.close
+	client&.close
+	driver&.close
+end
+~~~
+
+### Using a Pool to Manage Sessions
+
+If you are running multiple tests in parallel, you may want to use a session pool to manage the sessions. This can be done as follows:
+
+~~~ ruby
+require 'async/webdriver'
+
+Async do
+	bridge = Async::WebDriver::Bridge::Pool.new(Async::WebDriver::Bridge::Chrome.new(headless: false))
+	
+	session = bridge.session
+	# Set the implicit wait timeout to 10 seconds since we are dealing with the real internet (which can be slow):
+	session.implicit_wait_timeout = 10_000
+	
+	session.visit('https://google.com')
+	
+	session.fill_in('q', 'async-webdriver')
+	session.click_button("I'm Feeling Lucky")
+	
+	puts session.document_title
+ensure
+	session&.close
+	bridge&.close
+end
+~~~
+
+The sessions will be cached and reused if possible.
+
+## Integration vs Unit Testing
+
+`async-webdriver` is designed for integration testing. It is not designed for unit testing (e.g. wrapping a tool like `rack-test` as `capybara` can do). It is designed for testing your application in a real browser and web server. It is designed for testing your application in the same way that a real user would use it. Unfortunately, this style of integration testing is significantly slower than unit testing, but it is also significantly more representative of how your application will behave in production. There are other tools, e.g. [rack-test](https://github.com/rack/rack-test) which provide significantly faster unit testing, but they do not test how your application will behave in an actual web browser. A comprehensive test suite should include both unit tests and integration tests.
+
+### Headless Mode
+
+During testing, often you will want to see the real browser window to determine if the test is working correctly. By default, for performance reasons, `async-webdriver` will run the browser in headless mode. This means that the browser will not be visible on the screen. If you want to see the browser window, you can disable headless mode by setting the `headless` option to `false`:
+
+~~~ shell
+$ ASYNC_WEBDRIVER_BRIDGE_HEADLESS=false ./webdriver-script.rb
+~~~

data/context/github-actions-integration.md

@@ -0,0 +1,68 @@
+# GitHub Actions Integrations
+
+This guide explains how to use `async-webdriver` with GitHub Actions.
+
+We recommend using the [browser-actions](https://github.com/browser-actions) for setting up `chromedriver` and `geckodriver`. They are pre-configured to work with `async-webdriver` and are easy to use.
+
+## Pipeline Configuration
+
+The following example shows how to setup both `chromedriver` and `geckodriver` in a single pipeline:
+
+~~~ yaml
+name: Test
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+env:
+  CONSOLE_OUTPUT: XTerm
+
+jobs:
+  test:
+    name: ${{matrix.ruby}} on ${{matrix.os}}
+    runs-on: ${{matrix.os}}-latest
+    continue-on-error: ${{matrix.experimental}}
+    
+    strategy:
+      matrix:
+        os:
+          - ubuntu
+          - macos
+        
+        ruby:
+          - "3.0"
+          - "3.1"
+          - "3.2"
+        
+        experimental: [false]
+        
+        include:
+          - os: ubuntu
+            ruby: truffleruby
+            experimental: true
+          - os: ubuntu
+            ruby: jruby
+            experimental: true
+          - os: ubuntu
+            ruby: head
+            experimental: true
+    
+    steps:
+    - uses: actions/checkout@v3
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{matrix.ruby}}
+        bundler-cache: true
+    
+    - uses: browser-actions/setup-chrome@v1
+    - uses: browser-actions/setup-firefox@v1
+    - uses: browser-actions/setup-geckodriver@latest
+      with:
+        token: ${{secrets.GITHUB_TOKEN}}
+    
+    - name: Run tests
+      timeout-minutes: 10
+      run: bundle exec bake test
+~~~

data/context/index.yaml

@@ -0,0 +1,24 @@
+# Automatically generated context index for Utopia::Project guides.
+# Do not edit then files in this directory directly, instead edit the guides and then run `bake utopia:project:agent:context:update`.
+---
+description: A native library implementing the W3C WebDriver client specification.
+metadata:
+  documentation_uri: https://socketry.github.io/async-webdriver/
+  funding_uri: https://github.com/sponsors/ioquatix
+  source_code_uri: https://github.com/socketry/async-webdriver.git
+files:
+- path: getting-started.md
+  title: Getting Started
+  description: This guide explains how to use `async-webdriver` for controlling a
+    browser.
+- path: debugging.md
+  title: Debugging
+  description: This guide explains how to debug WebDriver issues by capturing HTML
+    source and screenshots when tests fail.
+- path: github-actions-integration.md
+  title: GitHub Actions Integrations
+  description: This guide explains how to use `async-webdriver` with GitHub Actions.
+- path: sus-integration.md
+  title: Sus Integration
+  description: This guide will show you how to integrate `async-webdriver` with the
+    sus test framework.

data/context/sus-integration.md

@@ -0,0 +1,51 @@
+# Sus Integration
+
+This guide will show you how to integrate `async-webdriver` with the sus test framework.
+
+## Usage
+
+Sus has out of the box support for `async-webdriver`. You can use it like this:
+
+```shell
+$ bundle add sus-fixtures-async-http sus-fixtures-async-webdriver protocol-rack
+$ bundle update
+```
+
+Then write your integration test:
+
+```ruby
+# test/my_integration_test.rb
+
+require "sus/fixtures/async/http/server_context"
+require "sus/fixtures/async/webdriver/session_context"
+
+require "protocol/rack/adapter"
+require "rack/builder"
+
+describe "my website" do
+	include Sus::Fixtures::Async::HTTP::ServerContext
+	include Sus::Fixtures::Async::WebDriver::SessionContext
+	
+	def middleware
+		Protocol::Rack::Adapter.new(app)
+	end
+	
+	def app
+		Rack::Builder.load_file(File.expand_path("../config.ru", __dir__))
+	end
+	
+	it "has a title" do
+		navigate_to("/")
+		
+		expect(session.document_title).to be == "Example"
+	end
+	
+	it "has a paragraph" do
+		navigate_to("/")
+		
+		expect(session).to have_element(tag_name: "p")
+	end
+end
+```
+
+For more information, refer to the [sus-fixtures-async-webdriver](https://github.com/socketry/sus-fixtures-async-webdriver) documentation.

data/lib/async/webdriver/error.rb

@@ -9,147 +9,147 @@ module Async
 	module WebDriver
 		class Error < StandardError
 		end
-
+		
 		# The Element Click command could not be completed because the element receiving the events is obscuring the element that was requested clicked.
 		class ElementClickInterceptedError < Error
 			CODE = "element click intercepted"
 		end
-
+		
 		# A command could not be completed because the element is not pointer- or keyboard interactable.
 		class ElementNotInteractableError < Error
 			CODE = "element not interactable"
 		end
-
+		
 		# Navigation caused the user agent to hit a certificate warning, which is usually the result of an expired or invalid TLS certificate.
 		class InsecureCertificateError < Error
 			CODE = "insecure certificate"
 		end
-
+		
 		# The arguments passed to a command are either invalid or malformed.
 		class InvalidArgumentError < Error
 			CODE = "invalid argument"
 		end
-
+		
 		# An illegal attempt was made to set a cookie under a different domain than the current page.
 		class InvalidCookieDomainError < Error
 			CODE = "invalid cookie domain"
 		end
-
+		
 		# A command could not be completed because the element is in an invalid state, e.g. attempting to clear an element that isn’t both editable and resettable.
 		class InvalidElementStateError < Error
 			CODE = "invalid element state"
 		end
-
+		
 		# Argument was an invalid selector.
 		class InvalidSelectorError < Error
 			CODE = "invalid selector"
 		end
-
+		
 		# Occurs if the given session id is not in the list of active sessions, meaning the session either does not exist or that it’s not active.
 		class InvalidSessionIdError < Error
 			CODE = "invalid session id"
 		end
-
+		
 		# An error occurred while executing JavaScript supplied by the user.
 		class JavaScriptError < Error
 			CODE = "javascript error"
 		end
-
+		
 		# The target for mouse interaction is not in the browser’s viewport and cannot be brought into that viewport.
 		class MoveTargetOutOfBoundsError < Error
 			CODE = "move target out of bounds"
 		end
-
+		
 		# An attempt was made to operate on a modal dialog when one was not open.
 		class NoSuchAlertError < Error
 			CODE = "no such alert"
 		end
-
+		
 		# No cookie matching the given path name was found amongst the associated cookies of the current browsing context’s active document.
 		class NoSuchCookieError < Error
 			CODE = "no such cookie"
 		end
-
+		
 		# An element could not be located on the page using the given search parameters.
 		class NoSuchElementError < Error
 			CODE = "no such element"
 		end
-
+		
 		# A command to switch to a frame could not be satisfied because the frame could not be found.
 		class NoSuchFrameError < Error
 			CODE = "no such frame"
 		end
-
+		
 		# A command to switch to a window could not be satisfied because the window could not be found.
 		class NoSuchWindowError < Error
 			CODE = "no such window"
 		end
-
+		
 		# The element does not have a shadow root.
 		class NoSuchShadowRootError < Error
 			CODE = "no such shadow root"
 		end
-
+		
 		# A script did not complete before its timeout expired.
 		class ScriptTimeoutError < Error
 			CODE = "script timeout error"
 		end
-
+		
 		# A new session could not be created.
 		class SessionNotCreatedError < Error
 			CODE = "session not created"
 		end
-
+		
 		# A command failed because the referenced element is no longer attached to the DOM.
 		class StaleElementReferenceError < Error
 			CODE = "stale element reference"
 		end
-
+		
 		# A command failed because the referenced shadow root is no longer attached to the DOM.
 		class DetachedShadowRootError < Error
 			CODE = "detached shadow root"
 		end
-
+		
 		# An operation did not complete before its timeout expired.
 		class TimeoutError < Error
 			CODE = "timeout"
 		end
-
+		
 		# A command to set a cookie’s value could not be satisfied.
 		class UnableToSetCookieError < Error
 			CODE = "unable to set cookie"
 		end
-
+		
 		# A screen capture was made impossible.
 		class UnableToCaptureScreenError < Error
 			CODE = "unable to capture screen"
 		end
-
+		
 		# A modal dialog was open, blocking this operation.
 		class UnexpectedAlertOpenError < Error
 			CODE = "unexpected alert open"
 		end
-
+		
 		# A command could not be executed because the remote end is not aware of it.
 		class UnknownCommandError < Error
 			CODE = "unknown command"
 		end
-
+		
 		# An unknown error occurred in the remote end while processing the command.
 		class UnknownError < Error
 			CODE = "unknown error"
 		end
-
+		
 		# The requested command matched a known URL but did not match any method for that URL.
 		class UnknownMethodError < Error
 			CODE = "unknown method"
 		end
-
+		
 		# Indicates that a command that should have executed properly cannot be supported for some reason.
 		class UnsupportedOperationError < Error
 			CODE = "unsupported operation"
 		end
-
+		
 		ERROR_CODES = {
 			ElementClickInterceptedError::CODE => ElementClickInterceptedError,
 			ElementNotInteractableError::CODE => ElementNotInteractableError,

data/lib/async/webdriver/scope/screen_capture.rb

@@ -13,7 +13,7 @@ module Async
 				# Take a screenshot of the current page or element.
 				# @returns [String] The screenshot as a Base64 encoded string.
 				def screenshot
-					reply = current_scope.post("screenshot")
+					reply = current_scope.get("screenshot")
 					
 					return Base64.decode64(reply)
 				end

data/lib/async/webdriver/version.rb

@@ -5,6 +5,6 @@
 
 module Async
 	module WebDriver
-		VERSION = "0.8.0"
+		VERSION = "0.9.1"
 	end
 end

data/readme.md

@@ -16,6 +16,8 @@ Please see the [project documentation](https://socketry.github.io/async-webdrive
 
   - [Getting Started](https://socketry.github.io/async-webdriver/guides/getting-started/index) - This guide explains how to use `async-webdriver` for controlling a browser.
 
+  - [Debugging](https://socketry.github.io/async-webdriver/guides/debugging/index) - This guide explains how to debug WebDriver issues by capturing HTML source and screenshots when tests fail.
+
   - [GitHub Actions Integrations](https://socketry.github.io/async-webdriver/guides/github-actions-integration/index) - This guide explains how to use `async-webdriver` with GitHub Actions.
 
   - [Sus Integration](https://socketry.github.io/async-webdriver/guides/sus-integration/index) - This guide will show you how to integrate `async-webdriver` with the sus test framework.
@@ -24,6 +26,10 @@ Please see the [project documentation](https://socketry.github.io/async-webdrive
 
 Please see the [project releases](https://socketry.github.io/async-webdriver/releases/index) for all releases.
 
+### v0.9.0
+
+  - Fix `Scope#screenshot` to use the correct HTTP method (`GET` instead of `POST`).
+
 ### v0.8.0
 
   - Fix `fill_in` `<select>` on Safari.

data/releases.md

@@ -1,5 +1,9 @@
 # Releases
 
+## v0.9.0
+
+  - Fix `Scope#screenshot` to use the correct HTTP method (`GET` instead of `POST`).
+
 ## v0.8.0
 
   - Fix `fill_in` `<select>` on Safari.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-webdriver
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Samuel Williams
@@ -112,6 +112,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- context/debugging.md
+- context/getting-started.md
+- context/github-actions-integration.md
+- context/index.yaml
+- context/sus-integration.md
 - lib/async/webdriver.rb
 - lib/async/webdriver/bridge.rb
 - lib/async/webdriver/bridge/chrome.rb
@@ -164,7 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A native library implementing the W3C WebDriver client specification.
 test_files: []