playwright-ruby-client 1.59.1 → 1.61.0

data/lib/playwright/page_assertions_impl.rb

@@ -28,7 +28,7 @@ module Playwright
       result = @frame.expect(nil, expression, expect_options, title)
 
       if result["matches"] == @is_not
-        actual = result["received"]
+        actual = received_actual(result)
 
         log =
           if result.key?("log")
@@ -53,19 +53,35 @@ module Playwright
         if result['errorMessage']
           error_message = "\n#{result['errorMessage']}"
         end
-        out = "#{out_message}\nActual value #{actual}#{error_message} #{log}"
+        out = "#{out_message}\nActual value #{actual}#{error_message} #{log}#{aria_snapshot(result)}"
         raise AssertionError.new(out)
       else
         true
       end
     end
 
+    private def received_actual(result)
+      received = result['received']
+      if received.is_a?(Hash)
+        received['value']
+      else
+        received
+      end
+    end
+
+    private def aria_snapshot(result)
+      aria_snapshot = result.dig('received', 'ariaSnapshot')
+      return '' unless aria_snapshot
+
+      "\nAria snapshot:\n#{aria_snapshot}\n"
+    end
+
     private def _not # "not" is reserved in Ruby
       PageAssertionsImpl.new(
         @page,
         @default_expect_timeout,
         !@is_not,
-        @message
+        @custom_message
       )
     end
 
@@ -150,5 +166,19 @@ module Playwright
       )
     end
     _define_negation :to_have_url
+
+    def to_match_aria_snapshot(expected, timeout: nil)
+      expect_impl(
+        'to.match.aria',
+        {
+          expectedValue: expected,
+          timeout: timeout,
+        },
+        expected,
+        'Page expected to match Aria snapshot',
+        'Expect "to_match_aria_snapshot"',
+      )
+    end
+    _define_negation :to_match_aria_snapshot
   end
 end

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
@@ -85,7 +86,12 @@ module Playwright
     end
 
     private def handle_screencast_frame(event)
-      @on_frame&.call(Base64.strict_decode64(event['data']))
+      @on_frame&.call({
+        data: Base64.strict_decode64(event['data']),
+        timestamp: event['timestamp'],
+        viewportWidth: event['viewportWidth'],
+        viewportHeight: event['viewportHeight'],
+      })
     end
   end
 end

data/lib/playwright/url_matcher.rb

@@ -5,6 +5,7 @@ module Playwright
     def initialize(url, base_url:)
       @url = url
       @base_url = base_url
+      validate_glob_pattern if @url.is_a?(String)
     end
 
     def as_pattern
@@ -37,5 +38,39 @@ module Playwright
         @url
       end
     end
+
+    private def validate_glob_pattern
+      in_group = false
+      escaped = false
+
+      @url.each_char do |char|
+        if escaped
+          escaped = false
+          next
+        end
+
+        if char == '\\'
+          escaped = true
+          next
+        end
+
+        case char
+        when '{'
+          if in_group
+            raise ArgumentError.new("Invalid glob pattern #{@url.inspect}: nested '{' is not supported")
+          end
+          in_group = true
+        when '}'
+          unless in_group
+            raise ArgumentError.new("Invalid glob pattern #{@url.inspect}: unmatched '}'")
+          end
+          in_group = false
+        end
+      end
+
+      if in_group
+        raise ArgumentError.new("Invalid glob pattern #{@url.inspect}: unmatched '{'")
+      end
+    end
   end
 end

data/lib/playwright/version.rb

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

data/lib/playwright/waiter.rb

@@ -12,33 +12,14 @@ module Playwright
       @registered_listeners = Set.new
       @listeners_mutex = Mutex.new
       @logs = []
-      wait_for_event_info_before
+      send_wait_info(waitId: @wait_id, phase: 'before', event: @event)
     end
 
-    private def wait_for_event_info_before
-      @channel.async_send_message_to_server(
-        "waitForEventInfo",
-        {
-          "info": {
-            "waitId": @wait_id,
-            "phase": "before",
-            "event": @event,
-          }
-        },
-      )
-    end
-
-    private def wait_for_event_info_after(error: nil)
-      @channel.async_send_message_to_server(
-        "waitForEventInfo",
-        {
-          "info": {
-            "waitId": @wait_id,
-            "phase": "after",
-            "error": error,
-          }.compact,
-        },
-      )
+    private def send_wait_info(params)
+      @channel.async_send_message_to_server('__waitInfo__', params.compact)
+    rescue
+      # Fire-and-forget. The server intentionally does not reply and this must
+      # not affect the API call that is being waited for.
     end
 
     def reject_on_event(emitter, event, error_or_proc, predicate: nil)
@@ -89,7 +70,7 @@ module Playwright
       cleanup
       return if @result.resolved?
       @result.fulfill(result)
-      wait_for_event_info_after
+      send_wait_info(waitId: @wait_id, phase: 'after')
     end
 
     private def reject(error)
@@ -98,7 +79,7 @@ module Playwright
       klass = error.is_a?(TimeoutError) ? TimeoutError : Error
       ex = klass.new(message: "#{error.message}#{format_log_recording(@logs)}")
       @result.reject(ex)
-      wait_for_event_info_after(error: ex)
+      send_wait_info(waitId: @wait_id, phase: 'after', error: ex.message)
     end
 
     # @param [Playwright::EventEmitter]
@@ -135,20 +116,7 @@ module Playwright
 
     def log(message)
       @logs << message
-      begin
-        @channel.async_send_message_to_server(
-          "waitForEventInfo",
-          {
-            "info": {
-              "waitId": @wait_id,
-              "phase": "log",
-              "message": message,
-            },
-          },
-        )
-      rescue => err
-        # ignore
-      end
+      send_wait_info(waitId: @wait_id, phase: 'log', message: message)
     end
 
     # @param logs [Array<String>]

data/lib/playwright/web_storage_impl.rb

@@ -0,0 +1,34 @@
+module Playwright
+  # ref: https://github.com/microsoft/playwright/blob/main/packages/playwright-core/src/client/webStorage.ts
+  define_api_implementation :WebStorageImpl do
+    # @param page [ChannelOwners::Page]
+    # @param kind [String] 'local' or 'session'
+    def initialize(page, kind)
+      @page = page
+      @kind = kind
+    end
+
+    def items
+      @page.channel.send_message_to_server('webStorageItems', kind: @kind)
+    end
+
+    def get_item(name)
+      @page.channel.send_message_to_server('webStorageGetItem', kind: @kind, name: name)
+    end
+
+    def set_item(name, value)
+      @page.channel.send_message_to_server('webStorageSetItem', kind: @kind, name: name, value: value)
+      nil
+    end
+
+    def remove_item(name)
+      @page.channel.send_message_to_server('webStorageRemoveItem', kind: @kind, name: name)
+      nil
+    end
+
+    def clear
+      @page.channel.send_message_to_server('webStorageClear', kind: @kind)
+      nil
+    end
+  end
+end

data/lib/playwright.rb

@@ -27,6 +27,7 @@ require 'playwright/route_handler'
 require 'playwright/select_option_values'
 require 'playwright/timeout_settings'
 require 'playwright/transport'
+require 'playwright/json_pipe_transport'
 require 'playwright/url_matcher'
 require 'playwright/version'
 require 'playwright/screencast'

data/lib/playwright_api/api_request.rb

@@ -20,7 +20,7 @@ module Playwright
           storageState: nil,
           timeout: nil,
           userAgent: nil)
-      raise NotImplementedError.new('new_context is not implemented yet.')
+      wrap_impl(@impl.new_context(baseURL: unwrap_impl(baseURL), clientCertificates: unwrap_impl(clientCertificates), extraHTTPHeaders: unwrap_impl(extraHTTPHeaders), failOnStatusCode: unwrap_impl(failOnStatusCode), httpCredentials: unwrap_impl(httpCredentials), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), maxRedirects: unwrap_impl(maxRedirects), proxy: unwrap_impl(proxy), storageState: unwrap_impl(storageState), timeout: unwrap_impl(timeout), userAgent: unwrap_impl(userAgent)))
     end
   end
 end

data/lib/playwright_api/api_request_context.rb

@@ -3,21 +3,21 @@ module Playwright
   # This API is used for the Web API testing. You can use it to trigger API endpoints, configure micro-services, prepare
   # environment or the service to your e2e test.
   #
-  # Each Playwright browser context has associated with it `APIRequestContext` instance which shares cookie storage with
-  # the browser context and can be accessed via [`property: BrowserContext.request`] or [`property: Page.request`].
-  # It is also possible to create a new APIRequestContext instance manually by calling [`method: APIRequest.newContext`].
+  # Each Playwright browser context has an associated `APIRequestContext`, accessible via
+  # [`property: BrowserContext.request`] or [`property: Page.request`] (these return the
+  #
+  # **same instance** — `page.request` is a shortcut for `page.context().request`).
+  # You can also create a standalone, isolated instance with [`method: APIRequest.newContext`].
   #
   # **Cookie management**
   #
-  # `APIRequestContext` returned by [`property: BrowserContext.request`] and [`property: Page.request`] shares cookie
-  # storage with the corresponding `BrowserContext`. Each API request will have `Cookie` header populated with the
-  # values from the browser context. If the API response contains `Set-Cookie` header it will automatically update
-  # `BrowserContext` cookies and requests made from the page will pick them up. This means that if you log in using
-  # this API, your e2e test will be logged in and vice versa.
+  # The `APIRequestContext` returned by [`property: BrowserContext.request`] and
+  #
+  # [`property: Page.request`] uses the same cookie jar as its `BrowserContext`:
   #
-  # If you want API requests to not interfere with the browser cookies you should create a new `APIRequestContext` by
-  # calling [`method: APIRequest.newContext`]. Such `APIRequestContext` object will have its own isolated cookie
-  # storage.
+  # If you want API requests that do **not** share cookies with the browser, create an
+  # isolated context via [`method: APIRequest.newContext`]. Such `APIRequestContext`
+  # object will have its own isolated cookie storage.
   #
   # ```python sync
   # import os
@@ -67,6 +67,10 @@ module Playwright
   # ```
   class APIRequestContext < PlaywrightApi
 
+    def tracing # property
+      wrap_impl(@impl.tracing)
+    end
+
     #
     # Sends HTTP(S) [DELETE](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/DELETE) request and returns its response.
     # The method will populate request cookies from the context and update
@@ -286,12 +290,6 @@ module Playwright
       raise NotImplementedError.new('storage_state is not implemented yet.')
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def off(event, callback)
@@ -304,6 +302,12 @@ module Playwright
       event_emitter_proxy.once(event, callback)
     end
 
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
+    end
+
     private def event_emitter_proxy
       @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end

data/lib/playwright_api/api_response.rb

@@ -55,6 +55,18 @@ module Playwright
       wrap_impl(@impl.ok)
     end
 
+    #
+    # 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.
+    def security_details
+      wrap_impl(@impl.security_details)
+    end
+
+    #
+    # 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.
+    def server_addr
+      wrap_impl(@impl.server_addr)
+    end
+
     #
     # Contains the status code of the response (e.g., 200 for a success).
     def status

data/lib/playwright_api/browser.rb

@@ -175,7 +175,7 @@ module Playwright
     #
     # Binds the browser to a named pipe or web socket, making it available for other clients to connect to.
     def bind(title, host: nil, port: nil, workspaceDir: nil)
-      raise NotImplementedError.new('bind is not implemented yet.')
+      wrap_impl(@impl.bind(unwrap_impl(title), host: unwrap_impl(host), port: unwrap_impl(port), workspaceDir: unwrap_impl(workspaceDir)))
     end
 
     #
@@ -206,7 +206,7 @@ module Playwright
     #
     # Unbinds the browser server previously bound with [`method: Browser.bind`].
     def unbind
-      raise NotImplementedError.new('unbind is not implemented yet.')
+      wrap_impl(@impl.unbind)
     end
 
     #
@@ -215,12 +215,6 @@ module Playwright
       wrap_impl(@impl.version)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def off(event, callback)
@@ -233,6 +227,12 @@ module Playwright
       event_emitter_proxy.once(event, callback)
     end
 
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
+    end
+
     private def event_emitter_proxy
       @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end

data/lib/playwright_api/browser_context.rb

@@ -25,6 +25,13 @@ module Playwright
       wrap_impl(@impl.clock)
     end
 
+    #
+    # Virtual WebAuthn authenticator for this context. Lets tests seed credentials and intercept
+    # `navigator.credentials.create()` / `navigator.credentials.get()` ceremonies.
+    def credentials # property
+      wrap_impl(@impl.credentials)
+    end
+
     #
     # Debugger allows to pause and resume the execution.
     def debugger # property
@@ -174,8 +181,8 @@ module Playwright
     # with sync_playwright() as playwright:
     #     run(playwright)
     # ```
-    def expose_binding(name, callback, handle: nil)
-      wrap_impl(@impl.expose_binding(unwrap_impl(name), unwrap_impl(callback), handle: unwrap_impl(handle)))
+    def expose_binding(name, callback)
+      wrap_impl(@impl.expose_binding(unwrap_impl(name), unwrap_impl(callback)))
     end
 
     #
@@ -489,6 +496,11 @@ module Playwright
       raise NotImplementedError.new('wait_for_event is not implemented yet.')
     end
 
+    # @nodoc
+    def browser=(req)
+      wrap_impl(@impl.browser=(unwrap_impl(req)))
+    end
+
     # @nodoc
     def enable_debug_console!
       wrap_impl(@impl.enable_debug_console!)
@@ -509,17 +521,6 @@ module Playwright
       wrap_impl(@impl.options=(unwrap_impl(req)))
     end
 
-    # @nodoc
-    def browser=(req)
-      wrap_impl(@impl.browser=(unwrap_impl(req)))
-    end
-
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def off(event, callback)
@@ -532,6 +533,12 @@ module Playwright
       event_emitter_proxy.once(event, callback)
     end
 
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
+    end
+
     private def event_emitter_proxy
       @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end

data/lib/playwright_api/browser_type.rb

@@ -28,8 +28,9 @@ module Playwright
           exposeNetwork: nil,
           headers: nil,
           slowMo: nil,
-          timeout: nil)
-      raise NotImplementedError.new('connect is not implemented yet.')
+          timeout: nil,
+          &block)
+      wrap_impl(@impl.connect(unwrap_impl(endpoint), exposeNetwork: unwrap_impl(exposeNetwork), headers: unwrap_impl(headers), slowMo: unwrap_impl(slowMo), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
     end
 
     #
@@ -50,12 +51,14 @@ module Playwright
     # ```
     def connect_over_cdp(
           endpointURL,
+          artifactsDir: nil,
           headers: nil,
           isLocal: nil,
+          noDefaults: nil,
           slowMo: nil,
           timeout: nil,
           &block)
-      wrap_impl(@impl.connect_over_cdp(unwrap_impl(endpointURL), headers: unwrap_impl(headers), isLocal: unwrap_impl(isLocal), slowMo: unwrap_impl(slowMo), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
+      wrap_impl(@impl.connect_over_cdp(unwrap_impl(endpointURL), artifactsDir: unwrap_impl(artifactsDir), headers: unwrap_impl(headers), isLocal: unwrap_impl(isLocal), noDefaults: unwrap_impl(noDefaults), slowMo: unwrap_impl(slowMo), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
     end
 
     #
@@ -181,12 +184,6 @@ module Playwright
       wrap_impl(@impl.name)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def off(event, callback)
@@ -199,6 +196,12 @@ module Playwright
       event_emitter_proxy.once(event, callback)
     end
 
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
+    end
+
     private def event_emitter_proxy
       @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end

data/lib/playwright_api/cdp_session.rb

@@ -31,12 +31,6 @@ module Playwright
       wrap_impl(@impl.send_message(unwrap_impl(method), params: unwrap_impl(params)))
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def off(event, callback)
@@ -49,6 +43,12 @@ module Playwright
       event_emitter_proxy.once(event, callback)
     end
 
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
+    end
+
     private def event_emitter_proxy
       @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end

data/lib/playwright_api/credentials.rb

@@ -0,0 +1,120 @@
+module Playwright
+  #
+  # `Credentials` is a virtual WebAuthn authenticator scoped to a `BrowserContext`. 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**
+  #
+  # ```python sync
+  # context = browser.new_context()
+  #
+  # # A passkey your backend already provisioned for a test user.
+  # context.credentials.create(
+  #     "example.com",
+  #     id=known_credential_id,  # base64url
+  #     user_handle=known_user_handle,  # base64url
+  #     private_key=known_private_key,  # base64url PKCS#8 (DER)
+  #     public_key=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**
+  #
+  # ```python sync
+  # # 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(rp_id="example.com")
+  # with open("playwright/.auth/passkey.json", "w") as f:
+  #     json.dump(credential, f)
+  # ```
+  #
+  # ```python sync
+  # # later test: seed the captured passkey so the app starts already enrolled.
+  # with open("playwright/.auth/passkey.json") as f:
+  #     credential = json.load(f)
+  # context = browser.new_context()
+  # context.credentials.create(
+  #     credential["rpId"],
+  #     id=credential["id"],
+  #     user_handle=credential["userHandle"],
+  #     private_key=credential["privateKey"],
+  #     public_key=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**
+  class Credentials < PlaywrightApi
+
+    #
+    # 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 [`method: Credentials.install`] is called, no interception is in place and the page sees
+    # the platform's native (or absent) WebAuthn behaviour. Seeding credentials with
+    # [`method: Credentials.create`] without installing populates the authenticator, but the
+    # page will never see those credentials.
+    def install
+      wrap_impl(@impl.install)
+    end
+
+    #
+    # 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 [`method: Credentials.install`] before navigating to a page that uses WebAuthn.
+    def create(
+          rpId,
+          id: nil,
+          privateKey: nil,
+          publicKey: nil,
+          userHandle: nil)
+      wrap_impl(@impl.create(unwrap_impl(rpId), id: unwrap_impl(id), privateKey: unwrap_impl(privateKey), publicKey: unwrap_impl(publicKey), userHandle: unwrap_impl(userHandle)))
+    end
+
+    #
+    # Removes a credential from the authenticator by its id. Works for any credential currently held —
+    # both those seeded with [`method: Credentials.create`] and those the page registered itself by
+    # calling `navigator.credentials.create()`.
+    def delete(id)
+      wrap_impl(@impl.delete(unwrap_impl(id)))
+    end
+
+    #
+    # Returns every credential currently held by the authenticator, optionally filtered by `rpId` or
+    # `id`. This includes both credentials seeded with [`method: 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 [`method: Credentials.create`] — see the second example in the class overview.
+    def get(id: nil, rpId: nil)
+      wrap_impl(@impl.get(id: unwrap_impl(id), rpId: unwrap_impl(rpId)))
+    end
+  end
+end