playwright-ruby-client 1.59.1 → 1.60.0

data/lib/playwright/channel_owners/browser_context.rb

@@ -20,7 +20,6 @@ module Playwright
       @request = ChannelOwners::APIRequestContext.from(@initializer['requestContext'])
       @request.send(:_update_timeout_settings, @timeout_settings)
       @clock = ClockImpl.new(self)
-      @har_recorders = {}
 
       @channel.on('bindingCall', ->(params) { on_binding(ChannelOwners::BindingCall.from(params['binding'])) })
       @channel.once('close', ->(_) { on_close })
@@ -34,8 +33,9 @@ module Playwright
       })
       @channel.on('pageError', ->(params) {
         on_page_error(
-          Error.parse(params['error']['error']),
+          Error.parse(params.dig('error', 'error') || params['error']),
           ChannelOwners::Page.from_nullable(params['page']),
+          params['location'],
         )
       })
       @channel.on('dialog', ->(params) {
@@ -82,7 +82,7 @@ module Playwright
 
       default_policy = record_har_path.end_with?('.zip') ? 'attach' : 'embed'
       content_policy = record_har_content || (record_har_omit_content ? 'omit' : default_policy)
-      record_into_har(record_har_path, nil,
+      @tracing.send(:record_into_har, record_har_path, nil,
         url: record_har_url_filter,
         update_content: content_policy,
         update_mode: record_har_mode || 'full',
@@ -186,8 +186,8 @@ module Playwright
       end
     end
 
-    private def on_page_error(error, page)
-      emit(Events::BrowserContext::WebError, WebError.new(error, page))
+    private def on_page_error(error, page, location)
+      emit(Events::BrowserContext::WebError, WebError.new(error, page, location))
       if page
         page.emit(Events::Page::PageError, error)
       end
@@ -337,19 +337,15 @@ module Playwright
       ChannelOwners::Disposable.from(result['disposable'])
     end
 
-    def expose_binding(name, callback, handle: nil)
+    def expose_binding(name, callback)
       if @pages.any? { |page| page.send(:has_bindings?, name) }
         raise ArgumentError.new("Function \"#{name}\" has been already registered in one of the pages")
       end
       if @bindings.key?(name)
         raise ArgumentError.new("Function \"#{name}\" has been already registered")
       end
-      params = {
-        name: name,
-        needsHandle: handle,
-      }.compact
       @bindings[name] = callback
-      result = @channel.send_message_to_server_result('exposeBinding', params)
+      result = @channel.send_message_to_server_result('exposeBinding', name: name)
       ChannelOwners::Disposable.from(result['disposable'])
     end
 
@@ -376,32 +372,9 @@ module Playwright
       update_interception_patterns
     end
 
-    private def record_into_har(har, page, url:, update_content:, update_mode:)
-      options = {
-        zip: har.end_with?('.zip'),
-        content: update_content || 'attach',
-      }
-
-      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 }
-      if page
-        params[:page] = page.channel
-      end
-
-      har_id = @channel.send_message_to_server('harStart', params)
-      @har_recorders[har_id] = { path: har, content: update_content || 'attach' }
-    end
-
     def route_from_har(har, notFound: nil, update: nil, updateContent: nil, updateMode: nil, url: nil)
       if update
-        record_into_har(har, nil, url: url, update_content: updateContent, update_mode: updateMode)
+        @tracing.send(:record_into_har, har, nil, url: url, update_content: updateContent, update_mode: updateMode)
         return
       end
 
@@ -443,6 +416,7 @@ module Playwright
         @browser.send(:remove_context, self)
         @browser.browser_type.send(:playwright_selectors_browser_contexts).delete(self)
       end
+      @tracing.send(:reset_stack_counter)
       emit(Events::BrowserContext::Close)
       @closed_promise.fulfill(true)
     end
@@ -452,30 +426,12 @@ module Playwright
       @close_was_called = true
       @close_reason = reason
       @request.dispose(reason: reason)
-      inner_close
+      @tracing.send(:export_all_hars)
       @channel.send_message_to_server('close', { reason: reason }.compact)
       @closed_promise.value!
       nil
     end
 
-    private def inner_close
-      @har_recorders.each do |har_id, params|
-        har = ChannelOwners::Artifact.from(@channel.send_message_to_server('harExport', harId: har_id))
-        # Server side will compress artifact if content is attach or if file is .zip.
-        compressed = params[:content] == "attach" || params[:path].end_with?('.zip')
-        need_comppressed = params[:path].end_with?('.zip')
-        if compressed && !need_comppressed
-          tmp_path = "#{params[:path]}.tmp"
-          har.save_as(tmp_path)
-          @connection.local_utils.har_unzip(tmp_path, params[:path])
-        else
-          har.save_as(params[:path])
-        end
-
-        har.delete
-      end
-    end
-
     # REMARK: enable_debug_console is playwright-ruby-client specific method.
     def enable_debug_console!
       # Ruby is not supported in Playwright officially,

data/lib/playwright/channel_owners/browser_type.rb

@@ -43,6 +43,7 @@ module Playwright
       browser = ChannelOwners::Browser.from(result['browser'])
       browser.send(:connect_to_browser_type, self, params[:tracesDir])
       context = ChannelOwners::BrowserContext.from(result['context'])
+      context.send(:update_options, context_options: params, browser_options: params)
       context.send(:initialize_har_from_options,
         record_har_content: params[:record_har_content],
         record_har_mode: params[:record_har_mode],
@@ -60,13 +61,45 @@ module Playwright
       end
     end
 
-    def connect_over_cdp(endpointURL, headers: nil, isLocal: nil, slowMo: nil, timeout: nil, &block)
+    def connect(endpoint, exposeNetwork: nil, headers: nil, slowMo: nil, timeout: nil, &block)
+      params = {
+        endpoint: endpoint,
+        headers: { 'x-playwright-browser' => name }.merge(headers || {}),
+        exposeNetwork: exposeNetwork,
+        slowMo: slowMo,
+        timeout: @timeout_settings.timeout(timeout),
+      }.compact
+
+      transport = JsonPipeTransport.new(@connection.local_utils, params)
+      connection = Connection.new(transport)
+      connection.mark_as_remote
+      connection.async_run
+
+      playwright = connection.initialize_playwright
+      browser = playwright.send(:pre_launched_browser)
+      browser.send(:should_close_connection_on_close!)
+      browser.send(:connect_to_browser_type, self, nil)
+
+      return browser unless block
+
+      begin
+        block.call(browser)
+      ensure
+        browser.close
+      end
+    rescue
+      connection&.stop
+      raise
+    end
+
+    def connect_over_cdp(endpointURL, 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,
         headers: headers,
         isLocal: isLocal,
+        noDefaults: noDefaults,
         slowMo: slowMo,
         timeout: @timeout_settings.timeout(timeout),
       }.compact

data/lib/playwright/channel_owners/frame.rb

@@ -1,3 +1,4 @@
+require 'base64'
 require_relative '../locator_utils'
 
 module Playwright
@@ -47,6 +48,7 @@ module Playwright
       unless @parent_frame
         if add == 'load'
           @page&.emit(Events::Page::Load, @page)
+          @page&.context&.emit(Events::BrowserContext::PageLoad, @page)
         elsif add == 'domcontentloaded'
           @page&.emit(Events::Page::DOMContentLoaded, @page)
         end
@@ -65,6 +67,7 @@ module Playwright
 
       unless event['error']
         @page&.emit(Events::Page::FrameNavigated, self)
+        @page&.context&.emit(Events::BrowserContext::FrameNavigated, self)
       end
     end
 
@@ -388,6 +391,23 @@ module Playwright
       nil
     end
 
+    def drop(
+          selector,
+          payload,
+          position: nil,
+          strict: nil,
+          timeout: nil)
+      params = {
+        selector: selector,
+        position: position,
+        strict: strict,
+        timeout: _timeout(timeout),
+      }.compact.merge(drop_payload_params(payload))
+      @channel.send_message_to_server('drop', params)
+
+      nil
+    end
+
     def dblclick(
           selector,
           button: nil,
@@ -690,8 +710,12 @@ module Playwright
       @channel.send_message_to_server('title')
     end
 
-    def highlight(selector)
-      @channel.send_message_to_server('highlight', selector: selector)
+    def highlight(selector, style: nil)
+      @channel.send_message_to_server('highlight', { selector: selector, style: style }.compact)
+    end
+
+    def hide_highlight(selector)
+      @channel.send_message_to_server('hideHighlight', selector: selector)
     end
 
     def expect(selector, expression, options, title)
@@ -712,12 +736,74 @@ module Playwright
       )
 
       if result.key?('received')
-        result['received'] = JavaScript::ValueParser.new(result['received']).parse
+        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
+        end
       end
 
       result
     end
 
+    private def drop_payload_params(payload)
+      unless payload.is_a?(Hash)
+        raise ArgumentError.new('payload must be a Hash')
+      end
+      unless payload.key?(:files) || payload.key?('files') || payload.key?(:data) || payload.key?('data')
+        raise ArgumentError.new('At least one of "files" or "data" must be specified')
+      end
+
+      params = {}
+      files = payload[:files] || payload['files']
+      params[:payloads] = drop_file_payloads(files) if files
+
+      data = payload[:data] || payload['data']
+      if data
+        params[:data] = data.map do |mime_type, value|
+          { mimeType: mime_type, value: value }
+        end
+      end
+
+      params
+    end
+
+    private def drop_file_payloads(files)
+      items =
+        if files.is_a?(Array)
+          files
+        else
+          [files]
+        end
+
+      if items.any? { |item| item.is_a?(String) || item.is_a?(File) }
+        unless items.all? { |item| item.is_a?(String) || item.is_a?(File) }
+          raise ArgumentError.new('File paths cannot be mixed with buffers')
+        end
+        return items.map do |item|
+          path = item.is_a?(File) ? item.path : item
+          raise ArgumentError.new('Dropping a directory is not supported - pass individual files.') if File.directory?(path)
+
+          {
+            name: File.basename(path),
+            buffer: Base64.strict_encode64(File.binread(path)),
+          }
+        end
+      end
+
+      items.map do |item|
+        unless item.is_a?(Hash)
+          raise ArgumentError.new('files must be file paths or file payload hashes')
+        end
+        buffer = item[:buffer] || item['buffer']
+        {
+          name: item[:name] || item['name'],
+          mimeType: item[:mimeType] || item['mimeType'],
+          buffer: Base64.strict_encode64(buffer),
+        }.compact
+      end
+    end
+
     # @param page [Page]
     # @note This method should be used internally. Accessed via .send method, so keep private!
     private def update_page_from_page(page)

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']
@@ -90,12 +90,14 @@ module Playwright
       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 +155,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 +174,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 +313,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 +436,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
 
@@ -676,9 +676,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 +952,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

@@ -213,7 +213,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/errors.rb

@@ -60,12 +60,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',