playwright-ruby-client 1.59.1 → 1.61.0

data/documentation/docs/include/api_coverage.md

@@ -293,6 +293,7 @@
 * go_forward
 * ~~request_gc~~
 * goto
+* hide_highlight
 * hover
 * inner_html
 * inner_text
@@ -364,6 +365,8 @@
 * ~~wait_for_event~~
 * clock
 * keyboard
+* local_storage
+* session_storage
 * mouse
 * request
 * screencast
@@ -404,6 +407,7 @@
 * expect_page
 * ~~wait_for_event~~
 * clock
+* credentials
 * ~~debugger~~
 * request
 * tracing
@@ -422,15 +426,15 @@
 * new_browser_cdp_session
 * new_context
 * new_page
-* ~~bind~~
+* bind
 * start_tracing
 * stop_tracing
-* ~~unbind~~
+* unbind
 * version
 
 ## BrowserType
 
-* ~~connect~~
+* connect
 * connect_over_cdp
 * executable_path
 * launch
@@ -443,7 +447,7 @@
 * chromium
 * devices
 * firefox
-* ~~request~~
+* request
 * selectors
 * webkit
 
@@ -451,10 +455,12 @@
 
 * start
 * start_chunk
+* start_har
 * group
 * group_end
 * stop
 * stop_chunk
+* stop_har
 
 ## Locator
 
@@ -474,6 +480,7 @@
 * description
 * dispatch_event
 * drag_to
+* drop
 * element_handle
 * element_handles
 * content_frame
@@ -493,6 +500,7 @@
 * get_by_test_id
 * get_by_text
 * get_by_title
+* hide_highlight
 * highlight
 * hover
 * inner_html
@@ -548,6 +556,8 @@
 * headers_array
 * json
 * ok
+* security_details
+* server_addr
 * status
 * status_text
 * text
@@ -564,10 +574,11 @@
 * post
 * put
 * ~~storage_state~~
+* tracing
 
-## ~~APIRequest~~
+## APIRequest
 
-* ~~new_context~~
+* new_context
 
 ## LocatorAssertions
 
@@ -628,59 +639,22 @@
 
 * not_to_have_title
 * not_to_have_url
+* to_match_aria_snapshot
+* not_to_match_aria_snapshot
 * to_have_title
 * to_have_url
 
-## Android
+## WebStorage
 
-* ~~connect~~
-* devices
-* set_default_timeout
-
-## AndroidDevice
-
-* close
-* ~~drag~~
-* ~~fill~~
-* ~~fling~~
-* info
-* ~~install_apk~~
-* launch_browser
-* ~~long_tap~~
-* model
-* ~~open~~
-* ~~pinch_close~~
-* ~~pinch_open~~
-* ~~press~~
-* ~~push~~
-* screenshot
-* ~~scroll~~
-* serial
-* ~~set_default_timeout~~
-* shell
-* ~~swipe~~
-* ~~tap_point~~
-* ~~wait~~
-* ~~wait_for_event~~
-* ~~web_view~~
-* ~~web_views~~
-* input
-
-## AndroidInput
-
-* drag
-* press
-* ~~swipe~~
-* tap_point
-* type
-
-## ~~AndroidSocket~~
-
-* ~~close~~
-* ~~write~~
+* items
+* get_item
+* set_item
+* remove_item
+* clear
 
-## ~~AndroidWebView~~
+## Credentials
 
-* ~~page~~
-* ~~pid~~
-* ~~pkg~~
+* install
+* create
+* delete
+* get

data/lib/playwright/api_request_impl.rb

@@ -0,0 +1,70 @@
+require 'base64'
+require 'json'
+
+module Playwright
+  define_api_implementation :APIRequestImpl do
+    def initialize(playwright)
+      @playwright = playwright
+    end
+
+    def new_context(
+          baseURL: nil,
+          clientCertificates: nil,
+          extraHTTPHeaders: nil,
+          failOnStatusCode: nil,
+          httpCredentials: nil,
+          ignoreHTTPSErrors: nil,
+          maxRedirects: nil,
+          proxy: nil,
+          storageState: nil,
+          timeout: nil,
+          userAgent: nil)
+      params = {
+        baseURL: baseURL,
+        clientCertificates: prepare_client_certificates(clientCertificates),
+        extraHTTPHeaders: extraHTTPHeaders ? HttpHeaders.new(extraHTTPHeaders).as_serialized : nil,
+        failOnStatusCode: failOnStatusCode,
+        httpCredentials: httpCredentials,
+        ignoreHTTPSErrors: ignoreHTTPSErrors,
+        maxRedirects: maxRedirects,
+        proxy: proxy,
+        storageState: prepare_storage_state(storageState),
+        timeout: timeout,
+        userAgent: userAgent,
+      }.compact
+
+      result = @playwright.channel.send_message_to_server_result('newRequest', params)
+      context = ChannelOwners::APIRequestContext.from(result['request'])
+      context.send(:_update_timeout_settings, TimeoutSettings.new.tap { |settings| settings.default_timeout = timeout if timeout })
+      context
+    end
+
+    private def prepare_storage_state(storage_state)
+      storage_state.is_a?(String) ? JSON.parse(File.read(storage_state)) : storage_state
+    end
+
+    private def prepare_client_certificates(client_certificates)
+      return unless client_certificates.is_a?(Array)
+
+      client_certificates.filter_map do |item|
+        out_record = {
+          origin: item[:origin],
+          passphrase: item[:passphrase],
+        }
+
+        { pfxPath: 'pfx', certPath: 'cert', keyPath: 'key' }.each do |key, out_key|
+          if (filepath = item[key])
+            out_record[out_key] = Base64.encode64(File.read(filepath)) rescue ''
+          elsif (value = item[out_key.to_sym])
+            out_record[out_key] = value
+          end
+        end
+
+        out_record.compact!
+        next nil if out_record.empty?
+
+        out_record
+      end
+    end
+  end
+end

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/api_request_context.rb

@@ -8,13 +8,17 @@ module Playwright
       @timeout_settings = TimeoutSettings.new
     end
 
+    attr_reader :tracing
+
     private def _update_timeout_settings(timeout_settings)
       @timeout_settings = timeout_settings
     end
 
     def dispose(reason: nil)
       @close_reason = reason
-      @channel.send_message_to_server('dispose')
+      @tracing.send(:export_all_hars)
+      @channel.send_message_to_server('dispose', { reason: reason }.compact)
+      @tracing.send(:reset_stack_counter)
     end
 
     def delete(url, **options)

data/lib/playwright/channel_owners/binding_call.rb

@@ -53,15 +53,9 @@ module Playwright
         page: PlaywrightApi.wrap(frame.page),
         frame: PlaywrightApi.wrap(frame),
       }
-      args =
-        if @initializer['handle']
-          handle = ChannelOwners::ElementHandle.from(@initializer['handle'])
-          [handle]
-        else
-          @initializer['args'].map do |arg|
-            JavaScript::ValueParser.new(arg).parse
-          end
-        end
+      args = @initializer['args'].map do |arg|
+        JavaScript::ValueParser.new(arg).parse
+      end
 
       begin
         result = PlaywrightApi.unwrap(callback.call(source, *args))

data/lib/playwright/channel_owners/browser.rb

@@ -87,6 +87,22 @@ module Playwright
       @initializer['version']
     end
 
+    def bind(title, host: nil, metadata: nil, port: nil, workspaceDir: nil)
+      params = {
+        title: title,
+        host: host,
+        metadata: metadata,
+        port: port,
+        workspaceDir: workspaceDir,
+      }.compact
+      @channel.send_message_to_server_result('startServer', params)
+    end
+
+    def unbind
+      @channel.send_message_to_server('stopServer')
+      nil
+    end
+
     def new_browser_cdp_session
       resp = @channel.send_message_to_server('newBrowserCDPSession')
       ChannelOwners::CDPSession.from(resp)
@@ -135,6 +151,7 @@ module Playwright
       if @browser_type
         setup_browser_context(context)
       end
+      emit(Events::Browser::Context, context)
     end
 
     private def setup_browser_context(context)

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,7 +20,7 @@ module Playwright
       @request = ChannelOwners::APIRequestContext.from(@initializer['requestContext'])
       @request.send(:_update_timeout_settings, @timeout_settings)
       @clock = ClockImpl.new(self)
-      @har_recorders = {}
+      @credentials = CredentialsImpl.new(self)
 
       @channel.on('bindingCall', ->(params) { on_binding(ChannelOwners::BindingCall.from(params['binding'])) })
       @channel.once('close', ->(_) { on_close })
@@ -34,8 +34,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 +83,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 +187,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 +338,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 +373,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 +417,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 +427,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,46 @@ 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, 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,
         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)
@@ -701,21 +725,102 @@ module Playwright
           .serialize
       end
 
-      result = @channel.send_message_to_server_result(
-        title, # title
-        "expect", # method
-        { # params
-          selector: selector,
-          expression: expression,
-          **options,
+      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
+
+        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
 
-      if result.key?('received')
-        result['received'] = JavaScript::ValueParser.new(result['received']).parse
+    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
 
-      result
+      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]