playwright-ruby-client 1.59.1 → 1.60.0

data/lib/playwright/json_pipe_transport.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Playwright
+  class JsonPipeTransport
+    def initialize(local_utils, params)
+      @local_utils = local_utils
+      @params = params
+    end
+
+    def on_message_received(&block)
+      @on_message = block
+    end
+
+    def on_driver_closed(&block)
+      @on_driver_closed = block
+    end
+
+    def on_driver_crashed(&block)
+      @on_driver_crashed = block
+    end
+
+    def send_message(message)
+      @pipe.channel.send_message_to_server('send', message: message)
+    end
+
+    def stop
+      @pipe&.channel&.send_message_to_server('close')
+    rescue TargetClosedError
+      nil
+    ensure
+      @pipe = nil
+    end
+
+    def async_run
+      @pipe = @local_utils.connect(@params)
+      @pipe.channel.on('message', ->(params) { @on_message&.call(params['message']) })
+      @pipe.channel.on('closed', ->(_params) { @on_driver_closed&.call })
+    end
+  end
+end

data/lib/playwright/locator_assertions_impl.rb

@@ -27,7 +27,7 @@ module Playwright
       result = @locator.expect(expression, expect_options, title)
 
       if result["matches"] == @is_not
-        actual = result["received"]
+        actual = received_actual(result)
 
         log =
           if result.key?("log")
@@ -52,19 +52,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
       LocatorAssertionsImpl.new(
         @locator,
         @default_expect_timeout,
         !@is_not,
-        @message
+        @custom_message
       )
     end
 
@@ -292,12 +308,13 @@ module Playwright
     end
     _define_negation :to_have_count
 
-    def to_have_css(name, value, timeout: nil)
+    def to_have_css(name, value, pseudo: nil, timeout: nil)
       expected_text = to_expected_text_values([value])
       expect_impl(
         "to.have.css",
         {
           expressionArg: name,
+          pseudo: pseudo,
           expectedText: expected_text,
           timeout: timeout,
         },

data/lib/playwright/locator_impl.rb

@@ -426,11 +426,12 @@ module Playwright
       end
     end
 
-    def aria_snapshot(depth: nil, mode: nil, timeout: nil, _track: nil)
+    def aria_snapshot(boxes: nil, depth: nil, mode: nil, timeout: nil, _track: nil)
       params = {
         selector: @selector,
         timeout: _timeout(timeout),
       }
+      params[:boxes] = boxes unless boxes.nil?
       params[:depth] = depth if depth
       params[:mode] = mode if mode
       if _track
@@ -485,6 +486,14 @@ module Playwright
       @frame.set_input_files(@selector, files, strict: true, noWaitAfter: noWaitAfter, timeout: timeout)
     end
 
+    def drop(payload, position: nil, timeout: nil)
+      @frame.drop(@selector,
+        payload,
+        strict: true,
+        position: position,
+        timeout: timeout)
+    end
+
     def tap_point(
           force: nil,
           modifiers: nil,
@@ -549,8 +558,13 @@ module Playwright
       @frame.eval_on_selector_all(@selector, "ee => ee.map(e => e.textContent || '')")
     end
 
-    def highlight
-      @frame.highlight(@selector)
+    def highlight(style: nil)
+      @frame.highlight(@selector, style: style)
+      DisposableStub.new { hide_highlight }
+    end
+
+    def hide_highlight
+      @frame.hide_highlight(@selector)
     end
 
     def _assertions(timeout, is_not, message)

data/lib/playwright/locator_utils.rb

@@ -66,12 +66,14 @@ module Playwright
       props = []
 
       ex = {
+        description: -> (value) { ['description', escape_for_attribute_selector_or_regex(value, options[:exact])]},
         includeHidden: -> (value) { ['include-hidden', value.to_s] },
         name: -> (value) { ['name', escape_for_attribute_selector_or_regex(value, options[:exact])]},
       }
 
       %i[
         checked
+        description
         disabled
         selected
         expanded

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

@@ -85,7 +85,11 @@ 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']),
+        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.60.0'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.60.0'
 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

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
 
     #

data/lib/playwright_api/browser_context.rb

@@ -174,8 +174,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,11 +489,6 @@ module Playwright
       raise NotImplementedError.new('wait_for_event is not implemented yet.')
     end
 
-    # @nodoc
-    def enable_debug_console!
-      wrap_impl(@impl.enable_debug_console!)
-    end
-
     # @nodoc
     def pause
       wrap_impl(@impl.pause)
@@ -514,6 +509,11 @@ module Playwright
       wrap_impl(@impl.browser=(unwrap_impl(req)))
     end
 
+    # @nodoc
+    def enable_debug_console!
+      wrap_impl(@impl.enable_debug_console!)
+    end
+
     # -- inherited from EventEmitter --
     # @nodoc
     def on(event, callback)

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
 
     #
@@ -52,10 +53,11 @@ module Playwright
           endpointURL,
           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), 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
 
     #

data/lib/playwright_api/frame.rb

@@ -454,6 +454,7 @@ module Playwright
     def get_by_role(
           role,
           checked: nil,
+          description: nil,
           disabled: nil,
           exact: nil,
           expanded: nil,
@@ -462,7 +463,7 @@ module Playwright
           name: nil,
           pressed: nil,
           selected: nil)
-      wrap_impl(@impl.get_by_role(unwrap_impl(role), checked: unwrap_impl(checked), disabled: unwrap_impl(disabled), exact: unwrap_impl(exact), expanded: unwrap_impl(expanded), includeHidden: unwrap_impl(includeHidden), level: unwrap_impl(level), name: unwrap_impl(name), pressed: unwrap_impl(pressed), selected: unwrap_impl(selected)))
+      wrap_impl(@impl.get_by_role(unwrap_impl(role), checked: unwrap_impl(checked), description: unwrap_impl(description), disabled: unwrap_impl(disabled), exact: unwrap_impl(exact), expanded: unwrap_impl(expanded), includeHidden: unwrap_impl(includeHidden), level: unwrap_impl(level), name: unwrap_impl(name), pressed: unwrap_impl(pressed), selected: unwrap_impl(selected)))
     end
 
     #
@@ -1041,18 +1042,28 @@ module Playwright
     end
 
     # @nodoc
-    def highlight(selector)
-      wrap_impl(@impl.highlight(unwrap_impl(selector)))
+    def detached=(req)
+      wrap_impl(@impl.detached=(unwrap_impl(req)))
     end
 
     # @nodoc
-    def expect(selector, expression, options, title)
-      wrap_impl(@impl.expect(unwrap_impl(selector), unwrap_impl(expression), unwrap_impl(options), unwrap_impl(title)))
+    def drop(selector, payload, position: nil, strict: nil, timeout: nil)
+      wrap_impl(@impl.drop(unwrap_impl(selector), unwrap_impl(payload), position: unwrap_impl(position), strict: unwrap_impl(strict), timeout: unwrap_impl(timeout)))
     end
 
     # @nodoc
-    def detached=(req)
-      wrap_impl(@impl.detached=(unwrap_impl(req)))
+    def highlight(selector, style: nil)
+      wrap_impl(@impl.highlight(unwrap_impl(selector), style: unwrap_impl(style)))
+    end
+
+    # @nodoc
+    def hide_highlight(selector)
+      wrap_impl(@impl.hide_highlight(unwrap_impl(selector)))
+    end
+
+    # @nodoc
+    def expect(selector, expression, options, title)
+      wrap_impl(@impl.expect(unwrap_impl(selector), unwrap_impl(expression), unwrap_impl(options), unwrap_impl(title)))
     end
 
     # -- inherited from EventEmitter --

data/lib/playwright_api/frame_locator.rb

@@ -136,6 +136,7 @@ module Playwright
     def get_by_role(
           role,
           checked: nil,
+          description: nil,
           disabled: nil,
           exact: nil,
           expanded: nil,
@@ -144,7 +145,7 @@ module Playwright
           name: nil,
           pressed: nil,
           selected: nil)
-      wrap_impl(@impl.get_by_role(unwrap_impl(role), checked: unwrap_impl(checked), disabled: unwrap_impl(disabled), exact: unwrap_impl(exact), expanded: unwrap_impl(expanded), includeHidden: unwrap_impl(includeHidden), level: unwrap_impl(level), name: unwrap_impl(name), pressed: unwrap_impl(pressed), selected: unwrap_impl(selected)))
+      wrap_impl(@impl.get_by_role(unwrap_impl(role), checked: unwrap_impl(checked), description: unwrap_impl(description), disabled: unwrap_impl(disabled), exact: unwrap_impl(exact), expanded: unwrap_impl(expanded), includeHidden: unwrap_impl(includeHidden), level: unwrap_impl(level), name: unwrap_impl(name), pressed: unwrap_impl(pressed), selected: unwrap_impl(selected)))
     end
 
     #

data/lib/playwright_api/locator.rb

@@ -106,8 +106,8 @@ module Playwright
     #
     # An AI-optimized snapshot, controlled by `mode`, is different from a default snapshot:
     # 1. Includes element references `[ref=e2]`. 2. Does not wait for an element matching the locator, and throws when no elements match. 3. Includes snapshots of `<iframe>`s inside the target.
-    def aria_snapshot(depth: nil, mode: nil, timeout: nil)
-      wrap_impl(@impl.aria_snapshot(depth: unwrap_impl(depth), mode: unwrap_impl(mode), timeout: unwrap_impl(timeout)))
+    def aria_snapshot(boxes: nil, depth: nil, mode: nil, timeout: nil)
+      wrap_impl(@impl.aria_snapshot(boxes: unwrap_impl(boxes), depth: unwrap_impl(depth), mode: unwrap_impl(mode), timeout: unwrap_impl(timeout)))
     end
 
     #
@@ -386,6 +386,28 @@ module Playwright
       wrap_impl(@impl.drag_to(unwrap_impl(target), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), sourcePosition: unwrap_impl(sourcePosition), steps: unwrap_impl(steps), targetPosition: unwrap_impl(targetPosition), timeout: unwrap_impl(timeout), trial: unwrap_impl(trial)))
     end
 
+    #
+    # Simulate an external drag-and-drop of files or clipboard-like data onto this locator.
+    #
+    # **Details**
+    #
+    # Dispatches the native `dragenter`, `dragover`, and `drop` events at the center of the
+    # target element with a synthetic [DataTransfer] carrying the provided files and/or data
+    # entries. Works cross-browser by constructing the [DataTransfer] in the page context.
+    #
+    # If the target element's `dragover` listener does not call `preventDefault()`, the target
+    # is considered to have rejected the drop: Playwright dispatches `dragleave` and this
+    # method throws.
+    #
+    # **Usage**
+    #
+    # Drop a file buffer onto an upload area:
+    #
+    # Drop plain text and a URL together:
+    def drop(payload, position: nil, timeout: nil)
+      wrap_impl(@impl.drop(unwrap_impl(payload), position: unwrap_impl(position), timeout: unwrap_impl(timeout)))
+    end
+
     #
     # Resolves given locator to the first matching DOM element. If there are no matching elements, waits for one. If multiple elements match the locator, throws.
     def element_handle(timeout: nil)
@@ -649,6 +671,7 @@ module Playwright
     def get_by_role(
           role,
           checked: nil,
+          description: nil,
           disabled: nil,
           exact: nil,
           expanded: nil,
@@ -657,7 +680,7 @@ module Playwright
           name: nil,
           pressed: nil,
           selected: nil)
-      wrap_impl(@impl.get_by_role(unwrap_impl(role), checked: unwrap_impl(checked), disabled: unwrap_impl(disabled), exact: unwrap_impl(exact), expanded: unwrap_impl(expanded), includeHidden: unwrap_impl(includeHidden), level: unwrap_impl(level), name: unwrap_impl(name), pressed: unwrap_impl(pressed), selected: unwrap_impl(selected)))
+      wrap_impl(@impl.get_by_role(unwrap_impl(role), checked: unwrap_impl(checked), description: unwrap_impl(description), disabled: unwrap_impl(disabled), exact: unwrap_impl(exact), expanded: unwrap_impl(expanded), includeHidden: unwrap_impl(includeHidden), level: unwrap_impl(level), name: unwrap_impl(name), pressed: unwrap_impl(pressed), selected: unwrap_impl(selected)))
     end
 
     #
@@ -747,10 +770,16 @@ module Playwright
       wrap_impl(@impl.get_by_title(unwrap_impl(text), exact: unwrap_impl(exact)))
     end
 
+    #
+    # Hides the element highlight previously added by [`method: Locator.highlight`].
+    def hide_highlight
+      wrap_impl(@impl.hide_highlight)
+    end
+
     #
     # Highlight the corresponding element(s) on the screen. Useful for debugging, don't commit the code that uses [`method: Locator.highlight`].
-    def highlight
-      wrap_impl(@impl.highlight)
+    def highlight(style: nil)
+      wrap_impl(@impl.highlight(style: unwrap_impl(style)))
     end
 
     #

data/lib/playwright_api/locator_assertions.rb

@@ -537,8 +537,8 @@ module Playwright
     # locator = page.get_by_role("button")
     # expect(locator).to_have_css("display", "flex")
     # ```
-    def to_have_css(name, value, timeout: nil)
-      wrap_impl(@impl.to_have_css(unwrap_impl(name), unwrap_impl(value), timeout: unwrap_impl(timeout)))
+    def to_have_css(name, value, pseudo: nil, timeout: nil)
+      wrap_impl(@impl.to_have_css(unwrap_impl(name), unwrap_impl(value), pseudo: unwrap_impl(pseudo), timeout: unwrap_impl(timeout)))
     end
 
     #