playwright-ruby-client 1.59.1 → 1.61.0

data/lib/playwright/channel_owners/json_pipe.rb

@@ -0,0 +1,4 @@
+module Playwright
+  define_channel_owner :JsonPipe do
+  end
+end

data/lib/playwright/channel_owners/local_utils.rb

@@ -37,8 +37,12 @@ module Playwright
       @channel.async_send_message_to_server('harClose', harId: har_id)
     end
 
-    def har_unzip(zip_file, har_file)
-      @channel.send_message_to_server('harUnzip', zipFile: zip_file, harFile: har_file)
+    def har_unzip(zip_file, har_file, resources_dir: nil)
+      @channel.send_message_to_server('harUnzip', {
+        zipFile: zip_file,
+        harFile: har_file,
+        resourcesDir: resources_dir,
+      }.compact)
     end
 
     def tracing_started(traces_dir, trace_name)
@@ -58,6 +62,11 @@ module Playwright
       nil
     end
 
+    def connect(params)
+      result = @channel.send_message_to_server_result('connect', params)
+      ChannelOwners::JsonPipe.from(result['pipe'])
+    end
+
     private def parse_device_descriptor(descriptor)
       # This return value can be passed into Browser#new_context as it is.
       # ex:

data/lib/playwright/channel_owners/page.rb

@@ -53,7 +53,7 @@ module Playwright
         on_frame_detached(ChannelOwners::Frame.from(params['frame']))
       })
       @channel.on('pageError', ->(params) {
-        emit(Events::Page::PageError, Error.parse(params['error']['error']))
+        emit(Events::Page::PageError, Error.parse(params.dig('error', 'error') || params['error']))
       })
       @channel.on('route', ->(params) { on_route(ChannelOwners::Route.from(params['route'])) })
       if @initializer['video']
@@ -86,16 +86,26 @@ 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
       emit(Events::Page::FrameAttached, frame)
+      @browser_context.emit(Events::BrowserContext::FrameAttached, frame)
     end
 
     private def on_frame_detached(frame)
       @frames.delete(frame)
       frame.detached = true
       emit(Events::Page::FrameDetached, frame)
+      @browser_context.emit(Events::BrowserContext::FrameDetached, frame)
     end
 
     private def on_route(route)
@@ -153,6 +163,7 @@ module Playwright
         @closed_or_crashed_promise.fulfill(close_error_with_reason)
       end
       emit(Events::Page::Close)
+      @browser_context.emit(Events::BrowserContext::PageClose, self)
     end
 
     private def on_crash
@@ -171,6 +182,7 @@ module Playwright
         artifact: artifact,
       )
       emit(Events::Page::Download, download)
+      @browser_context.emit(Events::BrowserContext::Download, download)
     end
 
     private def on_viewport_size_changed(params)
@@ -309,12 +321,8 @@ module Playwright
       ChannelOwners::Disposable.from(result['disposable'])
     end
 
-    def expose_binding(name, callback, handle: nil)
-      params = {
-        name: name,
-        needsHandle: handle,
-      }.compact
-      result = @channel.send_message_to_server_result('exposeBinding', params)
+    def expose_binding(name, callback)
+      result = @channel.send_message_to_server_result('exposeBinding', name: name)
       @bindings[name] = callback
       ChannelOwners::Disposable.from(result['disposable'])
     end
@@ -436,7 +444,7 @@ module Playwright
 
     def route_from_har(har, notFound: nil, update: nil, url: nil, updateContent: nil, updateMode: nil)
       if update
-        @browser_context.send(:record_into_har, har, self, url: url, update_content: updateContent, update_mode: updateMode)
+        @browser_context.tracing.send(:record_into_har, har, self, url: url, update_content: updateContent, update_mode: updateMode)
         return
       end
 
@@ -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?
@@ -676,9 +686,14 @@ module Playwright
       @channel.send_message_to_server('cancelPickLocator')
     end
 
-    def aria_snapshot(depth: nil, mode: nil, timeout: nil, _track: nil)
+    def hide_highlight
+      @channel.send_message_to_server('hideHighlight')
+    end
+
+    def aria_snapshot(boxes: nil, depth: nil, mode: nil, timeout: nil, _track: nil)
       params = { selector: 'body' }
       params[:timeout] = @timeout_settings.timeout(timeout)
+      params[:boxes] = boxes unless boxes.nil?
       params[:depth] = depth if depth
       params[:mode] = mode if mode
       if _track
@@ -947,8 +962,8 @@ module Playwright
       @main_frame.locator(result['selector'])
     end
 
-    def snapshot_for_ai(timeout: nil, depth: nil, _track: nil)
-      aria_snapshot(mode: 'ai', timeout: timeout, depth: depth, _track: _track)
+    def snapshot_for_ai(timeout: nil, depth: nil, boxes: nil, _track: nil)
+      aria_snapshot(mode: 'ai', timeout: timeout, depth: depth, boxes: boxes, _track: _track)
     end
 
     def _assertions(timeout, is_not, message)

data/lib/playwright/channel_owners/playwright.rb

@@ -34,6 +34,10 @@ module Playwright
       @connection.local_utils.devices
     end
 
+    def request
+      @request ||= APIRequestImpl.new(self)
+    end
+
     # used only from Playwright#connect_to_browser_server
     private def pre_launched_browser
       unless @initializer['preLaunchedBrowser']

data/lib/playwright/channel_owners/tracing.rb

@@ -1,5 +1,10 @@
 module Playwright
   define_channel_owner :Tracing do
+    private def after_initialize
+      @har_recorders = {}
+      @har_id = nil
+    end
+
     def start(name: nil, title: nil, screenshots: nil, snapshots: nil, sources: nil, live: nil)
       params = {
         name: name,
@@ -38,10 +43,7 @@ module Playwright
     end
 
     private def do_stop_chunk(file_path:)
-      if @is_tracing
-        @is_tracing = false
-        @connection.set_in_tracing(false)
-      end
+      reset_stack_counter
       local_utils = @connection.local_utils
 
       unless file_path
@@ -99,6 +101,105 @@ module Playwright
       )
     end
 
+    def start_har(path, content: nil, mode: nil, urlFilter: nil, resourcesDir: nil)
+      raise 'HAR recording has already been started' if @har_id
+      if resourcesDir && path.end_with?('.zip')
+        raise 'resourcesDir option is not compatible with a .zip har file'
+      end
+
+      default_content = path.end_with?('.zip') ? 'attach' : 'embed'
+      @har_id = record_into_har(path, nil,
+        url: urlFilter,
+        update_content: content || default_content,
+        update_mode: mode || 'full',
+        resources_dir: resourcesDir,
+      )
+      DisposableStub.new { stop_har }
+    end
+
+    def stop_har
+      har_id = @har_id
+      raise 'HAR recording has not been started' unless har_id
+
+      @har_id = nil
+      export_har(har_id)
+      nil
+    end
+
+    private def record_into_har(har, page, url:, update_content:, update_mode:, resources_dir: nil)
+      options = {
+        content: update_content || 'attach',
+        mode: update_mode || 'minimal',
+        harPath: har.end_with?('.zip') ? nil : har,
+        resourcesDir: resources_dir,
+      }.compact
+
+      if url.is_a?(Regexp)
+        regex = ::Playwright::JavaScript::Regex.new(url)
+        options[:urlRegexSource] = regex.source
+        options[:urlRegexFlags] = regex.flag
+      elsif url.is_a?(String)
+        options[:urlGlob] = url
+      end
+
+      params = { options: options }
+      params[:page] = page.channel if page
+
+      result = @channel.send_message_to_server_result('harStart', params)
+      har_id = result['harId'] || result[:harId]
+      @har_recorders[har_id] = { path: har, resources_dir: resources_dir }
+      har_id
+    end
+
+    private def export_har(har_id)
+      har_params = @har_recorders.delete(har_id)
+      return unless har_params
+
+      path = har_params[:path]
+      is_zip = path.end_with?('.zip')
+      local_utils = @connection.local_utils
+
+      if !@connection.remote?
+        result = @channel.send_message_to_server_result('harExport', harId: har_id, mode: 'entries')
+        return unless is_zip
+        raise 'Cannot save zipped HAR because localUtils is unavailable.' unless local_utils
+
+        local_utils.zip(
+          zipFile: path,
+          entries: result['entries'],
+          mode: 'write',
+          includeSources: false,
+        )
+        return
+      end
+
+      result = @channel.send_message_to_server_result('harExport', harId: har_id, mode: 'archive')
+      artifact = ChannelOwners::Artifact.from(result['artifact'])
+      if is_zip
+        artifact.save_as(path)
+        artifact.delete
+        return
+      end
+
+      raise 'Uncompressed har is not supported in thin clients' unless local_utils
+
+      tmp_path = "#{path}.tmp"
+      artifact.save_as(tmp_path)
+      local_utils.har_unzip(tmp_path, path, resources_dir: har_params[:resources_dir])
+      artifact.delete
+    end
+
+    private def export_all_hars
+      @har_recorders.keys.each { |har_id| export_har(har_id) }
+    end
+
+    private def reset_stack_counter
+      if @is_tracing
+        @is_tracing = false
+        @connection.set_in_tracing(false)
+      end
+    end
+
     private def update_traces_dir(traces_dir)
       @traces_dir = traces_dir
     end

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'])
@@ -213,7 +219,11 @@ module Playwright
         return
       end
 
-      object.channel.emit(method, replace_guids_with_channels(params))
+      if object.is_a?(ChannelOwners::JsonPipe) && method == 'message'
+        object.channel.emit(method, params)
+      else
+        object.channel.emit(method, replace_guids_with_channels(params))
+      end
     end
 
     def replace_channels_with_guids(payload)

data/lib/playwright/console_message_impl.rb

@@ -23,7 +23,16 @@ module Playwright
     end
 
     def location
-      @event['location']
+      location = @event['location']
+      return location unless location
+
+      {
+        'url' => location['url'],
+        'line' => location['lineNumber'],
+        'column' => location['columnNumber'],
+        'lineNumber' => location['lineNumber'],
+        'columnNumber' => location['columnNumber'],
+      }
     end
 
     def timestamp

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
@@ -60,12 +63,13 @@ module Playwright
   end
 
   class WebError
-    def initialize(error, page)
+    def initialize(error, page, location = nil)
       @error = error
       @page = PlaywrightApi.wrap(page)
+      @location = location
     end
 
-    attr_reader :error, :page
+    attr_reader :error, :page, :location
   end
 
   class AssertionError < StandardError; end

data/lib/playwright/events.rb

@@ -20,6 +20,7 @@ end
   },
 
   Browser: {
+    Context: 'context',
     Disconnected: 'disconnected'
   },
 
@@ -28,7 +29,13 @@ end
     Close: 'close',
     Console: 'console',
     Dialog: 'dialog',
+    Download: 'download',
+    FrameAttached: 'frameattached',
+    FrameDetached: 'framedetached',
+    FrameNavigated: 'framenavigated',
     Page: 'page',
+    PageClose: 'pageclose',
+    PageLoad: 'pageload',
     WebError: 'weberror',
     ServiceWorker: 'serviceworker',
     Request: 'request',

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

@@ -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:)
@@ -66,12 +74,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