playwright-ruby-client 1.58.1 → 1.59.1.alpha1

data/lib/playwright/channel_owners/page.rb

@@ -56,7 +56,9 @@ module Playwright
         emit(Events::Page::PageError, Error.parse(params['error']['error']))
       })
       @channel.on('route', ->(params) { on_route(ChannelOwners::Route.from(params['route'])) })
-      @channel.on('video', method(:on_video))
+      if @initializer['video']
+        @video_artifact = ChannelOwners::Artifact.from(@initializer['video'])
+      end
       @channel.on('viewportSizeChanged', method(:on_viewport_size_changed))
       @channel.on('webSocket', ->(params) {
         emit(Events::Page::WebSocket, ChannelOwners::WebSocket.from(params['webSocket']))
@@ -171,11 +173,6 @@ module Playwright
       emit(Events::Page::Download, download)
     end
 
-    private def on_video(params)
-      artifact = ChannelOwners::Artifact.from(params['artifact'])
-      video.send(:set_artifact, artifact)
-    end
-
     private def on_viewport_size_changed(params)
       @viewport_size = {
         width: params['viewportSize']['width'],
@@ -307,8 +304,9 @@ module Playwright
     end
 
     def expose_function(name, callback)
-      @channel.send_message_to_server('exposeBinding', name: name)
+      result = @channel.send_message_to_server_result('exposeBinding', name: name)
       @bindings[name] = ->(_source, *args) { callback.call(*args) }
+      ChannelOwners::Disposable.from(result['disposable'])
     end
 
     def expose_binding(name, callback, handle: nil)
@@ -316,8 +314,9 @@ module Playwright
         name: name,
         needsHandle: handle,
       }.compact
-      @channel.send_message_to_server('exposeBinding', params)
+      result = @channel.send_message_to_server_result('exposeBinding', params)
       @bindings[name] = callback
+      ChannelOwners::Disposable.from(result['disposable'])
     end
 
     def set_extra_http_headers(headers)
@@ -412,14 +411,15 @@ module Playwright
           raise ArgumentError.new('Either path or script parameter must be specified')
         end
 
-      @channel.send_message_to_server('addInitScript', source: source)
-      nil
+      result = @channel.send_message_to_server_result('addInitScript', source: source)
+      ChannelOwners::Disposable.from(result['disposable'])
     end
 
     def route(url, handler, times: nil)
       entry = RouteHandler.new(url, @browser_context.send(:base_url), handler, times)
       @routes.unshift(entry)
       update_interception_patterns
+      DisposableStub.new { unroute(url, handler: handler) }
     end
 
     def unroute_all(behavior: nil)
@@ -646,20 +646,49 @@ module Playwright
         timeout: timeout)
     end
 
-    def console_messages
-      messages = @channel.send_message_to_server('consoleMessages')
+    def console_messages(filter: nil)
+      params = {}
+      params[:filter] = filter if filter
+      messages = @channel.send_message_to_server('consoleMessages', params)
       messages.map do |message|
         ConsoleMessageImpl.new(message, self, nil)
       end
     end
 
-    def page_errors
-      errors = @channel.send_message_to_server('pageErrors')
+    def page_errors(filter: nil)
+      params = {}
+      params[:filter] = filter if filter
+      errors = @channel.send_message_to_server('pageErrors', params)
       errors.map do |error|
         Error.parse(error['error'])
       end
     end
 
+    def clear_console_messages
+      @channel.send_message_to_server('clearConsoleMessages')
+    end
+
+    def clear_page_errors
+      @channel.send_message_to_server('clearPageErrors')
+    end
+
+    def cancel_pick_locator
+      @channel.send_message_to_server('cancelPickLocator')
+    end
+
+    def aria_snapshot(depth: nil, mode: nil, timeout: nil, _track: nil)
+      params = { selector: 'body' }
+      params[:timeout] = @timeout_settings.timeout(timeout)
+      params[:depth] = depth if depth
+      params[:mode] = mode if mode
+      if _track
+        params.delete(:selector)
+        params[:track] = _track
+      end
+      result = @main_frame.channel.send_message_to_server_result('ariaSnapshot', params)
+      result['snapshot']
+    end
+
     def locator(
       selector,
       has: nil,
@@ -904,28 +933,26 @@ module Playwright
       decoded_binary
     end
 
+    def screencast
+      @screencast ||= Screencast.new(self)
+    end
+
     def video
       return nil unless @browser_context.send(:has_record_video_option?)
-      @video ||= Video.new(self)
+      @video ||= Video.new(self, artifact: @video_artifact)
     end
 
-    def snapshot_for_ai(timeout: nil, mode: nil, track: nil)
-      option_mode = mode || 'full'
-      unless ['full', 'incremental'].include?(option_mode)
-        raise ArgumentError.new("mode must be either 'full' or 'incremental'")
-      end
+    def pick_locator
+      result = @channel.send_message_to_server_result('pickLocator', {})
+      @main_frame.locator(result['selector'])
+    end
 
-      options = {
-        timeout: @timeout_settings.timeout(timeout),
-        mode: option_mode,
-      }
-      options[:track] = track if track
-      result = @channel.send_message_to_server_result('snapshotForAI', options)
-      if option_mode == 'full'
-        result['full']
-      elsif option_mode == 'incremental'
-        result['incremental']
-      end
+    def snapshot_for_ai(timeout: nil, depth: nil, _track: nil)
+      aria_snapshot(mode: 'ai', timeout: timeout, depth: depth, _track: _track)
+    end
+
+    def _assertions(timeout, is_not, message)
+      PageAssertionsImpl.new(self, timeout, is_not, message)
     end
 
     def start_js_coverage(resetOnNavigation: nil, reportAnonymousScripts: nil)

data/lib/playwright/channel_owners/request.rb

@@ -81,6 +81,10 @@ module Playwright
       end
     end
 
+    def existing_response
+      @response
+    end
+
     def response
       resp = @channel.send_message_to_server('response')
       ChannelOwners::Response.from_nullable(resp)
@@ -162,6 +166,10 @@ module Playwright
       res.send(:sizes)
     end
 
+    private def update_response(response)
+      @response = response
+    end
+
     private def update_redirected_to(request)
       @redirected_to = request
     end

data/lib/playwright/channel_owners/response.rb

@@ -7,6 +7,7 @@ module Playwright
     private def after_initialize
       @provisional_headers = RawHeaders.new(@initializer['headers'])
       @request = ChannelOwners::Request.from(@initializer['request'])
+      @request.send(:update_response, self)
       timing = @initializer['timing']
       @request.send(:update_timings,
         start_time: timing["startTime"],
@@ -74,6 +75,10 @@ module Playwright
       actual_headers.get_all(name)
     end
 
+    def http_version
+      @channel.send_message_to_server('httpVersion')
+    end
+
     def server_addr
       @channel.send_message_to_server('serverAddr')
     end

data/lib/playwright/channel_owners/tracing.rb

@@ -1,11 +1,12 @@
 module Playwright
   define_channel_owner :Tracing do
-    def start(name: nil, title: nil, screenshots: nil, snapshots: nil, sources: nil)
+    def start(name: nil, title: nil, screenshots: nil, snapshots: nil, sources: nil, live: nil)
       params = {
         name: name,
         screenshots: screenshots,
         snapshots: snapshots,
         sources: sources,
+        live: live,
       }.compact
       @include_sources = params[:sources] || false
       @channel.send_message_to_server('tracingStart', params)

data/lib/playwright/console_message_impl.rb

@@ -25,5 +25,9 @@ module Playwright
     def location
       @event['location']
     end
+
+    def timestamp
+      @event['timestamp']
+    end
   end
 end

data/lib/playwright/disposable.rb

@@ -0,0 +1,11 @@
+module Playwright
+  class Disposable
+    def initialize(impl)
+      @impl = impl
+    end
+
+    def dispose
+      @impl.dispose
+    end
+  end
+end

data/lib/playwright/har_router.rb

@@ -53,9 +53,10 @@ module Playwright
         # test when HAR was recorded but we'd abort it immediately.
         return if response['status'] == -1
 
+        headers = merge_har_response_headers(response['headers'])
         route.fulfill(
           status: response['status'],
-          headers: response['headers'].map { |header| [header['name'], header['value']] }.to_h,
+          headers: headers,
           body: Base64.strict_decode64(response['body']),
         )
       else
@@ -82,6 +83,20 @@ module Playwright
       page.once(Events::Page::Close, method(:dispose))
     end
 
+    private def merge_har_response_headers(headers)
+      headers.each_with_object({}) do |header, merged|
+        name = header['name']
+        value = header['value']
+
+        if name.casecmp('set-cookie').zero?
+          key = merged.keys.find { |existing| existing.casecmp('set-cookie').zero? } || name
+          merged[key] = merged[key] ? "#{merged[key]}\n#{value}" : value
+        else
+          merged[name] = value
+        end
+      end
+    end
+
     def dispose
       @local_utils.async_har_close(@har_id)
     end

data/lib/playwright/locator_impl.rb

@@ -426,11 +426,27 @@ module Playwright
       end
     end
 
-    def aria_snapshot(timeout: nil)
-      @frame.channel.send_message_to_server('ariaSnapshot', {
+    def aria_snapshot(depth: nil, mode: nil, timeout: nil, _track: nil)
+      params = {
         selector: @selector,
         timeout: _timeout(timeout),
-      }.compact)
+      }
+      params[:depth] = depth if depth
+      params[:mode] = mode if mode
+      if _track
+        params.delete(:selector)
+        params[:track] = _track
+      end
+      result = @frame.channel.send_message_to_server_result('ariaSnapshot', params.compact)
+      result['snapshot']
+    end
+
+    def normalize
+      resolved_selector = @frame.channel.send_message_to_server('resolveSelector', { selector: @selector })
+      LocatorImpl.new(
+        frame: @frame,
+        selector: resolved_selector,
+      )
     end
 
     def scroll_into_view_if_needed(timeout: nil)
@@ -537,6 +553,10 @@ module Playwright
       @frame.highlight(@selector)
     end
 
+    def _assertions(timeout, is_not, message)
+      LocatorAssertionsImpl.new(self, timeout, is_not, message)
+    end
+
     def expect(expression, options, title)
       @frame.expect(@selector, expression, options, title)
     end

data/lib/playwright/screencast.rb

@@ -0,0 +1,91 @@
+require 'base64'
+
+module Playwright
+  class Screencast
+    def initialize(page)
+      @page = page
+      @started = false
+      @save_path = nil
+      @artifact = nil
+      @on_frame = nil
+      @page.send(:channel).on('screencastFrame', method(:handle_screencast_frame))
+    end
+
+    def start(path: nil, size: nil, quality: nil, &on_frame)
+      raise 'Screencast is already started' if @started
+
+      @started = true
+      @on_frame = on_frame if on_frame
+
+      params = {}
+      params[:record] = true if path
+      params[:size] = size if size
+      params[:quality] = quality if quality
+      params[:sendFrames] = true if on_frame
+
+      result = @page.send(:channel).send_message_to_server_result('screencastStart', params)
+      if result.is_a?(Hash) && result['artifact']
+        @artifact = ChannelOwners::Artifact.from(result['artifact'])
+        @save_path = path
+      end
+
+      DisposableStub.new { stop }
+    end
+
+    def stop
+      return unless @started
+
+      @started = false
+      @on_frame = nil
+      @page.send(:channel).send_message_to_server('screencastStop')
+
+      if @save_path && @artifact
+        @artifact.save_as(@save_path)
+      end
+      @artifact = nil
+      @save_path = nil
+    end
+
+    def show_overlay(html, duration: nil)
+      params = { html: html }
+      params[:duration] = duration if duration
+      result = @page.send(:channel).send_message_to_server_result('screencastShowOverlay', params)
+      overlay_id = result['id'] if result.is_a?(Hash)
+      DisposableStub.new {
+        @page.send(:channel).send_message_to_server('screencastRemoveOverlay', id: overlay_id) if overlay_id
+      }
+    end
+
+    def show_chapter(title, description: nil, duration: nil)
+      params = { title: title }
+      params[:description] = description if description
+      params[:duration] = duration if duration
+      @page.send(:channel).send_message_to_server('screencastChapter', params)
+    end
+
+    def show_actions(duration: nil, fontSize: nil, position: nil)
+      params = {}
+      params[:duration] = duration if duration
+      params[:fontSize] = fontSize if fontSize
+      params[:position] = position if position
+      @page.send(:channel).send_message_to_server('screencastShowActions', params)
+      DisposableStub.new { hide_actions }
+    end
+
+    def hide_actions
+      @page.send(:channel).send_message_to_server('screencastHideActions')
+    end
+
+    def show_overlays
+      @page.send(:channel).send_message_to_server('screencastSetOverlayVisible', visible: true)
+    end
+
+    def hide_overlays
+      @page.send(:channel).send_message_to_server('screencastSetOverlayVisible', visible: false)
+    end
+
+    private def handle_screencast_frame(event)
+      @on_frame&.call(Base64.strict_decode64(event['data']))
+    end
+  end
+end

data/lib/playwright/test.rb

@@ -21,37 +21,6 @@ module Playwright
     end
 
     # ref: https://github.com/microsoft/playwright-python/blob/main/playwright/sync_api/__init__.py#L90
-    class Expect
-      def initialize
-        @default_expect_timeout = ::Playwright::Test.expect_timeout
-      end
-
-      def call(actual, is_not)
-        case actual
-        when Page
-          PageAssertions.new(
-            PageAssertionsImpl.new(
-              actual,
-              @default_expect_timeout,
-              is_not,
-              nil,
-            )
-          )
-        when Locator
-          LocatorAssertions.new(
-            LocatorAssertionsImpl.new(
-              actual,
-              @default_expect_timeout,
-              is_not,
-              nil,
-            )
-          )
-        else
-          raise NotImplementedError.new("Only locator assertions are currently implemented")
-        end
-      end
-    end
-
     module Matchers
       class PlaywrightMatcher
         def initialize(expectation_method, *args, **kwargs)
@@ -61,7 +30,7 @@ module Playwright
         end
 
         def matches?(actual)
-          Expect.new.call(actual, false).send(@method, *@args, **@kwargs)
+          assertions_for(actual, false).send(@method, *@args, **@kwargs)
           true
         rescue AssertionError => e
           @failure_message = e.full_message
@@ -69,7 +38,7 @@ module Playwright
         end
 
         def does_not_match?(actual)
-          Expect.new.call(actual, true).send(@method, *@args, **@kwargs)
+          assertions_for(actual, true).send(@method, *@args, **@kwargs)
           true
         rescue AssertionError => e
           @failure_message = e.full_message
@@ -83,6 +52,16 @@ module Playwright
         def failure_message_when_negated
           @failure_message
         end
+
+        private
+
+        def assertions_for(actual, is_not)
+          if actual.respond_to?(:_assertions)
+            actual._assertions(::Playwright::Test.expect_timeout, is_not, nil)
+          else
+            raise NotImplementedError.new("Only page and locator assertions are currently implemented")
+          end
+        end
       end
     end
 

data/lib/playwright/utils.rb

@@ -1,6 +1,22 @@
 require 'base64'
 
 module Playwright
+  class DisposableStub
+    def initialize(&block)
+      @block = block
+    end
+
+    def dispose
+      return unless @block
+
+      block = @block
+      @block = nil
+      block.call
+    rescue TargetClosedError
+      nil
+    end
+  end
+
   module Utils
     module PrepareBrowserContextOptions
       # @see https://github.com/microsoft/playwright/blob/5a2cfdbd47ed3c3deff77bb73e5fac34241f649d/src/client/browserContext.ts#L265
@@ -19,6 +35,9 @@ module Playwright
           if params[:record_video_size]
             params[:recordVideo][:size] = params.delete(:record_video_size)
           end
+          if params[:record_video_show_actions]
+            params[:recordVideo][:showActions] = params.delete(:record_video_show_actions)
+          end
         end
         if params[:storageState].is_a?(String)
           params[:storageState] = JSON.parse(File.read(params[:storageState]))

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '1.58.1'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.58.2'
+  VERSION = '1.59.1.alpha1'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.59.0'
 end

data/lib/playwright/video.rb

@@ -1,9 +1,11 @@
 module Playwright
   class Video
-    def initialize(page)
+    def initialize(page, artifact: nil)
       @page = page
       @artifact = Concurrent::Promises.resolvable_future
-      if @page.closed?
+      if artifact
+        @artifact.fulfill(artifact)
+      elsif @page.closed?
         on_page_closed
       else
         page.once('close', -> { on_page_closed })
@@ -16,9 +18,9 @@ module Playwright
       end
     end
 
-    # called only from Page#on_video via send(:set_artifact, artifact)
+    # called only from Page with send(:set_artifact, artifact)
     private def set_artifact(artifact)
-      @artifact.fulfill(artifact)
+      @artifact.fulfill(artifact) unless @artifact.resolved?
     end
 
     def path

data/lib/playwright.rb

@@ -20,6 +20,7 @@ require 'playwright/channel_owner'
 require 'playwright/http_headers'
 require 'playwright/input_files'
 require 'playwright/connection'
+require 'playwright/disposable'
 require 'playwright/har_router'
 require 'playwright/raw_headers'
 require 'playwright/route_handler'
@@ -28,6 +29,7 @@ require 'playwright/timeout_settings'
 require 'playwright/transport'
 require 'playwright/url_matcher'
 require 'playwright/version'
+require 'playwright/screencast'
 require 'playwright/video'
 require 'playwright/waiter'
 

data/lib/playwright_api/android.rb

@@ -21,7 +21,7 @@ module Playwright
     #
     # This methods attaches Playwright to an existing Android device.
     # Use [`method: Android.launchServer`] to launch a new Android server instance.
-    def connect(wsEndpoint, headers: nil, slowMo: nil, timeout: nil)
+    def connect(endpoint, headers: nil, slowMo: nil, timeout: nil)
       raise NotImplementedError.new('connect is not implemented yet.')
     end
 
@@ -43,12 +43,6 @@ module Playwright
       wrap_impl(@impl.set_default_navigation_timeout(unwrap_impl(timeout)))
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def on(event, callback)
@@ -61,6 +55,12 @@ module Playwright
       event_emitter_proxy.off(event, callback)
     end
 
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
+    end
+
     private def event_emitter_proxy
       @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end

data/lib/playwright_api/android_device.rb

@@ -204,12 +204,6 @@ module Playwright
       wrap_impl(@impl.tap_on(unwrap_impl(selector), duration: unwrap_impl(duration), timeout: unwrap_impl(timeout)))
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def on(event, callback)
@@ -222,6 +216,12 @@ module Playwright
       event_emitter_proxy.off(event, callback)
     end
 
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
+    end
+
     private def event_emitter_proxy
       @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end

data/lib/playwright_api/api_request_context.rb

@@ -286,12 +286,6 @@ module Playwright
       raise NotImplementedError.new('storage_state is not implemented yet.')
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
-    end
-
     # -- inherited from EventEmitter --
     # @nodoc
     def on(event, callback)
@@ -304,6 +298,12 @@ module Playwright
       event_emitter_proxy.off(event, callback)
     end
 
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
+    end
+
     private def event_emitter_proxy
       @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end