playwright-ruby-client 1.60.0 → 1.61.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac9256b441d66c5a19585735b23567b6dc1eedca695812ee3388f48918054970
-  data.tar.gz: 9a13c1dcfc540d7bc1120743af1806a338185a2bd6eb41331e2273425af790c6
+  metadata.gz: c45763ab237c198b8f2aa3afa3114ae0bf821481e57711516f5014547079f183
+  data.tar.gz: ed8d42f43cb28c8ae2a45755332582b6e51ac993a751de94fb1a25fff43f5532
 SHA512:
-  metadata.gz: f8fae6bb376c4586a90464a2db4d06b3362a822d191456dcf5ad75f74ae67ed99462403aa4cdca4d817eb58d59ec30380a9b72c5d6cee2f5475a0fda4e2c05a8
-  data.tar.gz: b59cc6913b92826850611eab5967f72c2545549f2ac83c8268d59d6ef61152523a1fcb62759278487661369449a817222ecd514a0c066ea913b3e4607a4b0463
+  metadata.gz: 90ac4618f354ca98c4d5a5c7284b23d752a098bf7128a246076964381f36d93680b78c89599b15b175afdb7274e6cea1882cfab64f9d9eab6dcb1317b0f0f894
+  data.tar.gz: 91cdfb64498f4e76f0f3a6f726fd49fa3d36dd7c6b692e843455bf8a9160a94216f13e324ffe90a2472c0b9ad573bd1d1ab241590629357d01562991ea299c63

data/documentation/docs/api/api_response.md

@@ -77,6 +77,24 @@ def ok
 
 Contains a boolean stating whether the response was successful (status in the range 200-299) or not.
 
+## security_details
+
+```
+def security_details
+```
+
+
+Returns SSL and other security information. Resolves to `null` for non-HTTPS responses. For redirected requests, returns the information for the last request in the redirect chain.
+
+## server_addr
+
+```
+def server_addr
+```
+
+
+Returns the IP address and port of the server. Resolves to `null` if the server address is not available. For redirected requests, returns the information for the last request in the redirect chain.
+
 ## status
 
 ```

data/documentation/docs/api/browser_context.md

@@ -521,6 +521,12 @@ Will throw an error if the context closes before new [Page](./page) is created.
 
 Playwright has ability to mock clock and passage of time.
 
+## credentials
+
+
+Virtual WebAuthn authenticator for this context. Lets tests seed credentials and intercept
+`navigator.credentials.create()` / `navigator.credentials.get()` ceremonies.
+
 ## request
 
 

data/documentation/docs/api/browser_type.md

@@ -41,6 +41,7 @@ This method attaches Playwright to an existing browser instance created via `Bro
 ```
 def connect_over_cdp(
       endpointURL,
+      artifactsDir: nil,
       headers: nil,
       isLocal: nil,
       noDefaults: nil,

data/documentation/docs/api/credentials.md

@@ -0,0 +1,132 @@
+---
+sidebar_position: 10
+---
+
+# Credentials
+
+
+[Credentials](./credentials) is a virtual WebAuthn authenticator scoped to a [BrowserContext](./browser_context). It lets tests
+register passkeys and answer `navigator.credentials.create()` / `navigator.credentials.get()`
+ceremonies in the page, without a real authenticator or hardware security key.
+
+There are two common ways to use it:
+
+**Usage: seed a known credential**
+
+```ruby
+context = browser.new_context
+
+# A passkey your backend already provisioned for a test user.
+context.credentials.create(
+  "example.com",
+  id: known_credential_id, # base64url
+  userHandle: known_user_handle, # base64url
+  privateKey: known_private_key, # base64url PKCS#8 (DER)
+  publicKey: known_public_key, # base64url SPKI (DER)
+)
+context.credentials.install
+
+page = context.new_page
+page.goto("https://example.com/login")
+# The page's navigator.credentials.get() is answered with the seeded passkey.
+```
+
+**Usage: capture a passkey, then reuse it**
+
+```ruby
+# setup test: let the app register a passkey, then save it.
+context = browser.new_context
+context.credentials.install
+
+page = context.new_page
+page.goto("https://example.com/register")
+page.get_by_role("button", name: "Create a passkey").click
+
+# Read back the passkey the page registered - it includes the private key.
+credential = context.credentials.get(rpId: "example.com").first
+File.write("playwright/.auth/passkey.json", JSON.generate(credential))
+```
+
+```ruby
+# later test: seed the captured passkey so the app starts already enrolled.
+credential = JSON.parse(File.read("playwright/.auth/passkey.json"))
+context = browser.new_context
+context.credentials.create(
+  credential["rpId"],
+  id: credential["id"],
+  userHandle: credential["userHandle"],
+  privateKey: credential["privateKey"],
+  publicKey: credential["publicKey"],
+)
+context.credentials.install
+
+page = context.new_page
+page.goto("https://example.com/login")
+# navigator.credentials.get() resolves the captured passkey - already signed in.
+```
+
+**Defaults**
+
+## install
+
+```
+def install
+```
+
+
+Installs the virtual WebAuthn authenticator into the context, overriding
+`navigator.credentials.create()` and `navigator.credentials.get()` in all current
+and future pages. Call this before the page first touches `navigator.credentials`.
+
+Required: until [Credentials#install](./credentials#install) is called, no interception is in place and the page sees
+the platform's native (or absent) WebAuthn behaviour. Seeding credentials with
+[Credentials#create](./credentials#create) without installing populates the authenticator, but the
+page will never see those credentials.
+
+## create
+
+```
+def create(
+      rpId,
+      id: nil,
+      privateKey: nil,
+      publicKey: nil,
+      userHandle: nil)
+```
+
+
+Seeds a virtual WebAuthn credential and returns it.
+
+With only `rpId`, generates a fresh **ECDSA P-256** keypair, credential id and user handle. The
+seeded credential is discoverable (resident), so the page can resolve it from both
+username-then-passkey and usernameless passkey flows. The returned object carries the private and public keys, so it can be persisted to disk and re-seeded in a later test.
+
+To **import a known credential**, supply all four of `id`, `userHandle`, `privateKey` and
+`publicKey` together.
+
+Call [Credentials#install](./credentials#install) before navigating to a page that uses WebAuthn.
+
+## delete
+
+```
+def delete(id)
+```
+
+
+Removes a credential from the authenticator by its id. Works for any credential currently held —
+both those seeded with [Credentials#create](./credentials#create) and those the page registered itself by
+calling `navigator.credentials.create()`.
+
+## get
+
+```
+def get(id: nil, rpId: nil)
+```
+
+
+Returns every credential currently held by the authenticator, optionally filtered by `rpId` or
+`id`. This includes both credentials seeded with [Credentials#create](./credentials#create) and credentials
+the page registered itself by calling `navigator.credentials.create()`.
+
+Each returned credential includes its private and public keys, so a passkey the app just
+registered can be saved and re-seeded into a later test with [Credentials#create](./credentials#create) — see the second example in the class overview.

data/documentation/docs/api/frame.md

@@ -291,7 +291,7 @@ puts frame.evaluate("1 + #{x}") # => "11"
 [ElementHandle](./element_handle) instances can be passed as an argument to the [Frame#evaluate](./frame#evaluate):
 
 ```ruby
-body_handle = frame.query_selector("body")
+body_handle = frame.evaluate_handle("document.body")
 html = frame.evaluate("([body, suffix]) => body.innerHTML + suffix", arg: [body_handle, "hello"])
 body_handle.dispose
 ```
@@ -321,14 +321,14 @@ a_window_handle # handle for the window object.
 A string can also be passed in instead of a function.
 
 ```ruby
-a_handle = page.evaluate_handle("document") # handle for the "document"
+a_handle = frame.evaluate_handle("document") # handle for the "document"
 ```
 
 [JSHandle](./js_handle) instances can be passed as an argument to the [Frame#evaluate_handle](./frame#evaluate_handle):
 
 ```ruby
-body_handle = page.evaluate_handle("document.body")
-result_handle = page.evaluate_handle("body => body.innerHTML", arg: body_handle)
+a_handle = frame.evaluate_handle("document.body")
+result_handle = frame.evaluate_handle("body => body.innerHTML", arg: a_handle)
 puts result_handle.json_value
 result_handle.dispose
 ```

data/documentation/docs/api/page.md

@@ -413,7 +413,7 @@ puts page.evaluate("1 + #{x}") # => "11"
 [ElementHandle](./element_handle) instances can be passed as an argument to the [Page#evaluate](./page#evaluate):
 
 ```ruby
-body_handle = page.query_selector("body")
+body_handle = page.evaluate_handle("document.body")
 html = page.evaluate("([body, suffix]) => body.innerHTML + suffix", arg: [body_handle, "hello"])
 body_handle.dispose
 ```
@@ -1561,7 +1561,7 @@ This method taps an element matching `selector` by performing the following step
 When all steps combined have not finished during the specified `timeout`, this method throws a
 `TimeoutError`. Passing zero timeout disables this.
 
-**NOTE**: [Page#tap_point](./page#tap_point) the method will throw if `hasTouch` option of the browser context is false.
+**NOTE**: [Page#tap_point](./page#tap_point) will throw if the `hasTouch` option of the browser context is false.
 
 ## text_content
 
@@ -2001,6 +2001,16 @@ Playwright has ability to mock clock and passage of time.
 
 ## keyboard
 
+## local_storage
+
+
+Provides access to the page's `localStorage` for the current origin. See [WebStorage](./web_storage).
+
+## session_storage
+
+
+Provides access to the page's `sessionStorage` for the current origin. See [WebStorage](./web_storage).
+
 ## mouse
 
 ## request

data/documentation/docs/api/touchscreen.md

@@ -19,4 +19,4 @@ def tap_point(x, y)
 
 Dispatches a `touchstart` and `touchend` event with a single touch at the position (`x`,`y`).
 
-**NOTE**: [Page#tap_point](./page#tap_point) the method will throw if `hasTouch` option of the browser context is false.
+**NOTE**: [Touchscreen#tap_point](./touchscreen#tap_point) will throw if the `hasTouch` option of the browser context is false.

data/documentation/docs/api/web_storage.md

@@ -0,0 +1,65 @@
+---
+sidebar_position: 10
+---
+
+# WebStorage
+
+
+WebStorage exposes the page's `localStorage` or `sessionStorage` for the current origin via an async,
+[browser-consistent](https://developer.mozilla.org/en-US/docs/Web/API/Storage) API.
+
+Instances are accessed through [Page#local_storage](./page#local_storage) and [Page#session_storage](./page#session_storage).
+
+```ruby
+page.goto("https://example.com")
+page.local_storage.set_item("token", "abc")
+token = page.local_storage.get_item("token")
+all = page.local_storage.items
+page.local_storage.remove_item("token")
+page.local_storage.clear
+```
+
+## items
+
+```
+def items
+```
+
+
+Returns all items in the storage as name/value pairs.
+
+## get_item
+
+```
+def get_item(name)
+```
+
+
+Returns the value for the given `name` if present.
+
+## set_item
+
+```
+def set_item(name, value)
+```
+
+
+Sets the value for the given `name`. Overwrites any existing value for that name.
+
+## remove_item
+
+```
+def remove_item(name)
+```
+
+
+Removes the item with the given `name`. No-op if the item is absent.
+
+## clear
+
+```
+def clear
+```
+
+
+Removes all items from the storage.

data/documentation/docs/include/api_coverage.md

@@ -365,6 +365,8 @@
 * ~~wait_for_event~~
 * clock
 * keyboard
+* local_storage
+* session_storage
 * mouse
 * request
 * screencast
@@ -405,6 +407,7 @@
 * expect_page
 * ~~wait_for_event~~
 * clock
+* credentials
 * ~~debugger~~
 * request
 * tracing
@@ -553,6 +556,8 @@
 * headers_array
 * json
 * ok
+* security_details
+* server_addr
 * status
 * status_text
 * text
@@ -638,3 +643,18 @@
 * not_to_match_aria_snapshot
 * to_have_title
 * to_have_url
+
+## WebStorage
+
+* items
+* get_item
+* set_item
+* remove_item
+* clear
+
+## Credentials
+
+* install
+* create
+* delete
+* get

data/lib/playwright/api_response_impl.rb

@@ -39,6 +39,14 @@ module Playwright
       @headers.headers_array
     end
 
+    def security_details
+      @initializer['securityDetails']
+    end
+
+    def server_addr
+      @initializer['serverAddr']
+    end
+
     class AlreadyDisposedError < StandardError
       def initialize
         super('Response has been disposed')

data/lib/playwright/channel_owners/browser_context.rb

@@ -5,7 +5,7 @@ module Playwright
 
     attr_accessor :browser
     attr_writer :owner_page, :options
-    attr_reader :clock, :tracing, :request
+    attr_reader :clock, :tracing, :request, :credentials
 
     private def after_initialize
       @options = @initializer['options']
@@ -20,6 +20,7 @@ module Playwright
       @request = ChannelOwners::APIRequestContext.from(@initializer['requestContext'])
       @request.send(:_update_timeout_settings, @timeout_settings)
       @clock = ClockImpl.new(self)
+      @credentials = CredentialsImpl.new(self)
 
       @channel.on('bindingCall', ->(params) { on_binding(ChannelOwners::BindingCall.from(params['binding'])) })
       @channel.once('close', ->(_) { on_close })

data/lib/playwright/channel_owners/browser_type.rb

@@ -92,11 +92,12 @@ module Playwright
       raise
     end
 
-    def connect_over_cdp(endpointURL, headers: nil, isLocal: nil, noDefaults: nil, slowMo: nil, timeout: nil, &block)
+    def connect_over_cdp(endpointURL, artifactsDir: nil, headers: nil, isLocal: nil, noDefaults: nil, slowMo: nil, timeout: nil, &block)
       raise 'Connecting over CDP is only supported in Chromium.' unless name == 'chromium'
 
       params = {
         endpointURL: endpointURL,
+        artifactsDir: artifactsDir,
         headers: headers,
         isLocal: isLocal,
         noDefaults: noDefaults,

data/lib/playwright/channel_owners/frame.rb

@@ -725,25 +725,44 @@ module Playwright
           .serialize
       end
 
-      result = @channel.send_message_to_server_result(
-        title, # title
-        "expect", # method
-        { # params
-          selector: selector,
-          expression: expression,
-          **options,
-        }.compact
-      )
-
-      if result.key?('received')
-        if result['received'].is_a?(Hash) && result['received'].key?('value')
-          result['received']['value'] = JavaScript::ValueParser.new(result['received']['value']).parse
-        elsif !result['received'].is_a?(Hash)
-          result['received'] = JavaScript::ValueParser.new(result['received']).parse
+      is_not = options[:isNot] || false
+
+      # Since Playwright 1.61, the `expect` command resolves on a successful
+      # match and rejects with FrameExpectErrorDetails on a mismatch/timeout.
+      begin
+        @channel.send_message_to_server_result(
+          title, # title
+          "expect", # method
+          { # params
+            selector: selector,
+            expression: expression,
+            **options,
+          }.compact
+        )
+        { 'matches' => !is_not }
+      rescue ::Playwright::Error => err
+        details = err.details || {}
+        received = details['received']
+        if received.is_a?(Hash)
+          received = received.dup
+          if received.key?('value')
+            received['value'] = JavaScript::ValueParser.new(received['value']).parse
+          end
         end
-      end
 
-      result
+        error_message =
+          if details['customErrorMessage']
+            "Error: #{details['customErrorMessage']}"
+          end
+
+        {
+          'matches' => is_not,
+          'received' => received,
+          'log' => err.raw_log,
+          'timedOut' => details['timedOut'],
+          'errorMessage' => error_message,
+        }.compact
+      end
     end
 
     private def drop_payload_params(payload)

data/lib/playwright/channel_owners/page.rb

@@ -86,6 +86,14 @@ module Playwright
       :viewport_size,
       :main_frame
 
+    def local_storage
+      @local_storage ||= WebStorageImpl.new(self, 'local')
+    end
+
+    def session_storage
+      @session_storage ||= WebStorageImpl.new(self, 'session')
+    end
+
     private def on_frame_attached(frame)
       frame.send(:update_page_from_page, self)
       @frames << frame
@@ -513,13 +521,15 @@ module Playwright
       end
       if @owned_context
         @owned_context.close
+      elsif runBeforeUnload
+        @channel.send_message_to_server('runBeforeUnload')
       else
-        options = { runBeforeUnload: runBeforeUnload }.compact
+        options = { reason: reason }.compact
         @channel.send_message_to_server('close', options)
       end
       nil
     rescue => err
-      raise if !target_closed_error?(err) || !runBeforeUnload
+      raise if !target_closed_error?(err) || runBeforeUnload
     end
 
     def closed?

data/lib/playwright/connection.rb

@@ -74,14 +74,18 @@ module Playwright
     end
 
     def async_send_message_to_server(guid, method, params, metadata: nil)
+      if method == '__waitInfo__' && @closed_error
+        return Concurrent::Promises.fulfilled_future(nil)
+      end
       return if @closed_error
 
       callback = Concurrent::Promises.resolvable_future
+      fire_and_forget = method == '__waitInfo__'
 
       with_generated_id do |id|
         # register callback promise object first.
         # @see https://github.com/YusukeIwaki/puppeteer-ruby/pull/34
-        @callbacks_mutex.synchronize { @callbacks[id] = callback }
+        @callbacks_mutex.synchronize { @callbacks[id] = callback } unless fire_and_forget
 
         _metadata = {}
         frames = []
@@ -112,6 +116,7 @@ module Playwright
           callback.reject(err)
           raise unless err.is_a?(Transport::AlreadyDisconnectedError)
         end
+        callback.fulfill(nil) if fire_and_forget
 
         if @tracing_count > 0 && !frames.empty? && guid != 'localUtils' && !remote?
           @local_utils.add_stack_to_tracing_no_reply(id, frames)
@@ -168,6 +173,7 @@ module Playwright
         if error && !msg['result']
           parsed_error = ::Playwright::Error.parse(error['error'])
           parsed_error.log = msg['log']
+          parsed_error.details = msg['errorDetails']
           callback.reject(parsed_error)
         else
           result = replace_guids_with_channels(msg['result'])

data/lib/playwright/credentials_impl.rb

@@ -0,0 +1,35 @@
+module Playwright
+  # ref: https://github.com/microsoft/playwright/blob/main/packages/playwright-core/src/client/credentials.ts
+  define_api_implementation :CredentialsImpl do
+    # @param browser_context [ChannelOwners::BrowserContext]
+    def initialize(browser_context)
+      @browser_context = browser_context
+    end
+
+    def install
+      @browser_context.channel.send_message_to_server('credentialsInstall')
+      nil
+    end
+
+    def create(rpId, id: nil, userHandle: nil, privateKey: nil, publicKey: nil)
+      params = {
+        rpId: rpId,
+        id: id,
+        userHandle: userHandle,
+        privateKey: privateKey,
+        publicKey: publicKey,
+      }.compact
+      @browser_context.channel.send_message_to_server('credentialsCreate', params)
+    end
+
+    def get(id: nil, rpId: nil)
+      params = { id: id, rpId: rpId }.compact
+      @browser_context.channel.send_message_to_server('credentialsGet', params)
+    end
+
+    def delete(id)
+      @browser_context.channel.send_message_to_server('credentialsDelete', id: id)
+      nil
+    end
+  end
+end

data/lib/playwright/errors.rb

@@ -31,10 +31,13 @@ module Playwright
       @stack = stack
     end
 
-    attr_reader :name, :message, :stack
+    attr_reader :name, :message, :stack, :raw_log
+    # Error details for `expect` failures (received value, timedOut, customErrorMessage).
+    attr_accessor :details
 
     def log=(log)
       return unless log
+      @raw_log = log
       format_call_log = log.join("\n  - ")
       @message = "#{@message}\nCall log:\n#{format_call_log}\n"
     end

data/lib/playwright/locator_utils.rb

@@ -39,7 +39,15 @@ module Playwright
     end
 
     private def get_by_test_id_selector(test_id_attribute_name, test_id)
-      "internal:testid=[#{test_id_attribute_name}=#{escape_for_attribute_selector_or_regex(test_id, true)}]"
+      "internal:testid=[#{encode_test_id_attribute_name(test_id_attribute_name)}=#{escape_for_attribute_selector_or_regex(test_id, true)}]"
+    end
+
+    private def encode_test_id_attribute_name(test_id_attribute_name)
+      if test_id_attribute_name.include?(',')
+        JSON.generate(test_id_attribute_name)
+      else
+        test_id_attribute_name
+      end
     end
 
     private def get_by_label_selector(text, exact:)

data/lib/playwright/screencast.rb

@@ -63,11 +63,12 @@ module Playwright
       @page.send(:channel).send_message_to_server('screencastChapter', params)
     end
 
-    def show_actions(duration: nil, fontSize: nil, position: nil)
+    def show_actions(duration: nil, fontSize: nil, position: nil, cursor: nil)
       params = {}
       params[:duration] = duration if duration
       params[:fontSize] = fontSize if fontSize
       params[:position] = position if position
+      params[:cursor] = cursor if cursor
       @page.send(:channel).send_message_to_server('screencastShowActions', params)
       DisposableStub.new { hide_actions }
     end
@@ -87,6 +88,7 @@ module Playwright
     private def handle_screencast_frame(event)
       @on_frame&.call({
         data: Base64.strict_decode64(event['data']),
+        timestamp: event['timestamp'],
         viewportWidth: event['viewportWidth'],
         viewportHeight: event['viewportHeight'],
       })

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '1.60.0'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.60.0'
+  VERSION = '1.61.0'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.61.1'
 end