playwright-ruby-client 1.20.2 → 1.23.0

data/lib/playwright/channel.rb

@@ -37,13 +37,11 @@ module Playwright
 
     # @param method [String]
     # @param params [Hash]
-    # @returns nil
+    # @returns [Concurrent::Promises::Future]
     def async_send_message_to_server(method, params = {})
       with_logging do |metadata|
         @connection.async_send_message_to_server(@guid, method, params, metadata: metadata)
       end
-
-      nil
     end
 
     private def with_logging(&block)

data/lib/playwright/channel_owners/browser.rb

@@ -5,6 +5,7 @@ module Playwright
     include Utils::PrepareBrowserContextOptions
 
     private def after_initialize
+      @browser_type = @parent
       @connected = true
       @closed_or_closing = false
       @should_close_connection_on_close = false
@@ -17,6 +18,10 @@ module Playwright
       @contexts.to_a
     end
 
+    def browser_type
+      @browser_type
+    end
+
     def connected?
       @connected
     end
@@ -30,6 +35,7 @@ module Playwright
       @contexts << context
       context.browser = self
       context.options = params
+      context.send(:update_browser_type, @browser_type)
       return context unless block
 
       begin
@@ -54,6 +60,13 @@ module Playwright
       end
     end
 
+    private def update_browser_type(browser_type)
+      @browser_type = browser_type
+      @contexts.each do |context|
+        context.send(:update_browser_type, browser_type)
+      end
+    end
+
     def close
       return if @closed_or_closing
       @closed_or_closing = true

data/lib/playwright/channel_owners/browser_context.rb

@@ -2,6 +2,8 @@ module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_browser_context.py
   define_channel_owner :BrowserContext do
     include Utils::Errors::SafeCloseError
+    include Utils::PrepareBrowserContextOptions
+
     attr_accessor :browser
     attr_writer :owner_page, :options
     attr_reader :tracing, :request
@@ -17,12 +19,17 @@ module Playwright
 
       @tracing = ChannelOwners::Tracing.from(@initializer['tracing'])
       @request = ChannelOwners::APIRequestContext.from(@initializer['APIRequestContext'])
+      @har_recorders = {}
 
       @channel.on('bindingCall', ->(params) { on_binding(ChannelOwners::BindingCall.from(params['binding'])) })
       @channel.once('close', ->(_) { on_close })
       @channel.on('page', ->(params) { on_page(ChannelOwners::Page.from(params['page']) )})
       @channel.on('route', ->(params) {
-        on_route(ChannelOwners::Route.from(params['route']), ChannelOwners::Request.from(params['request']))
+        Concurrent::Promises.future {
+          on_route(ChannelOwners::Route.from(params['route']), ChannelOwners::Request.from(params['request']))
+        }.rescue do |err|
+          puts err, err.backtrace
+        end
       })
       @channel.on('backgroundPage', ->(params) {
         on_background_page(ChannelOwners::Page.from(params['page']))
@@ -55,6 +62,16 @@ module Playwright
       @closed_promise = Concurrent::Promises.resolvable_future
     end
 
+    private def update_browser_type(browser_type)
+      @browser_type = browser_type
+      if @options[:recordHar]
+        @har_recorders[''] = {
+          path: @options[:recordHar][:path],
+          content: @options[:recordHar][:content]
+        }
+      end
+    end
+
     private def on_page(page)
       @pages << page
       emit(Events::BrowserContext::Page, page)
@@ -73,19 +90,29 @@ module Playwright
       wrapped_route = PlaywrightApi.wrap(route)
       wrapped_request = PlaywrightApi.wrap(request)
 
-      handler_entry = @routes.find do |entry|
-        entry.match?(request.url)
+      handled = @routes.any? do |handler_entry|
+        next false unless handler_entry.match?(request.url)
+
+        promise = Concurrent::Promises.resolvable_future
+        route.send(:set_handling_future, promise)
+
+        promise_handled = Concurrent::Promises.zip(
+          promise,
+          handler_entry.async_handle(wrapped_route, wrapped_request)
+        ).value!.first
+
+        promise_handled
       end
 
-      if handler_entry
-        handler_entry.async_handle(wrapped_route, wrapped_request)
+      @routes.reject!(&:expired?)
+      if @routes.count == 0
+        @channel.async_send_message_to_server('setNetworkInterceptionEnabled', enabled: false)
+      end
 
-        @routes.reject!(&:expired?)
-        if @routes.count == 0
-          @channel.async_send_message_to_server('setNetworkInterceptionEnabled', enabled: false)
+      unless handled
+        route.send(:async_continue_route).rescue do |err|
+          puts err, err.backtrace
         end
-      else
-        route.continue
       end
     end
 
@@ -266,6 +293,37 @@ module Playwright
       end
     end
 
+    private def record_into_har(har, page, notFound:, url:)
+      params = {
+        options: prepare_record_har_options(
+          record_har_path: har,
+          record_har_content: "attach",
+          record_har_mode: "minimal",
+          record_har_url_filter: url,
+        )
+      }
+      if page
+        params[:page] = page.channel
+      end
+      har_id = @channel.send_message_to_server('harStart', params)
+      @har_recorders[har_id] = { path: har, content: 'attach' }
+    end
+
+    def route_from_har(har, notFound: nil, update: nil, url: nil)
+      if update
+        record_into_har(har, nil, notFound: notFound, url: url)
+        return
+      end
+
+      router = HarRouter.create(
+        @connection.local_utils,
+        har.to_s,
+        notFound || "abort",
+        url_match: url,
+      )
+      router.add_context_route(self)
+    end
+
     def expect_event(event, predicate: nil, timeout: nil, &block)
       wait_helper = WaitHelper.new
       wait_helper.reject_on_timeout(timeout || @timeout_settings.timeout, "Timeout while waiting for event \"#{event}\"")
@@ -283,9 +341,19 @@ module Playwright
     end
 
     def close
-      if @options && @options.key?(:recordHar)
-        har = ChannelOwners::Artifact.from(@channel.send_message_to_server('harExport'))
-        har.save_as(@options[:recordHar][:path])
+      @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
       @channel.send_message_to_server('close')
@@ -367,5 +435,13 @@ module Playwright
     private def base_url
       @options[:baseURL]
     end
+
+    # called from InputFiles
+    # @param name [string]
+    # @return [WritableStream]
+    private def create_temp_file(name)
+      result = @channel.send_message_to_server('createTempFile', name: name)
+      ChannelOwners::WritableStream.from(result)
+    end
   end
 end

data/lib/playwright/channel_owners/browser_type.rb

@@ -13,6 +13,7 @@ module Playwright
     def launch(options, &block)
       resp = @channel.send_message_to_server('launch', options.compact)
       browser = ChannelOwners::Browser.from(resp)
+      browser.send(:update_browser_type, self)
       return browser unless block
 
       begin
@@ -29,6 +30,8 @@ module Playwright
 
       resp = @channel.send_message_to_server('launchPersistentContext', params.compact)
       context = ChannelOwners::Browser.from(resp)
+      context.options = params
+      context.send(:update_browser_type, self)
       return context unless block
 
       begin
@@ -54,6 +57,7 @@ module Playwright
 
       result = @channel.send_message_to_server_result('connectOverCDP', params)
       browser = ChannelOwners::Browser.from(result['browser'])
+      browser.send(:update_browser_type, self)
 
       if result['defaultContext']
         context = ChannelOwners::BrowserContext.from(result['defaultContext'])

data/lib/playwright/channel_owners/element_handle.rb

@@ -205,9 +205,14 @@ module Playwright
       end
 
       def set_input_files(files, noWaitAfter: nil, timeout: nil)
-        file_payloads = InputFiles.new(files).as_params
-        params = { files: file_payloads, noWaitAfter: noWaitAfter, timeout: timeout }.compact
-        @channel.send_message_to_server('setInputFiles', params)
+        frame = owner_frame
+        unless frame
+          raise 'Cannot set input files to detached element'
+        end
+
+        method_name, params = InputFiles.new(frame.page.context, files).as_method_and_params
+        params.merge!({ noWaitAfter: noWaitAfter, timeout: timeout }.compact)
+        @channel.send_message_to_server(method_name, params)
 
         nil
       end
@@ -282,18 +287,22 @@ module Playwright
 
       def screenshot(
         animations: nil,
+        caret: nil,
         mask: nil,
         omitBackground: nil,
         path: nil,
         quality: nil,
+        scale: nil,
         timeout: nil,
         type: nil)
 
         params = {
           animations: animations,
+          caret: caret,
           omitBackground: omitBackground,
           path: path,
           quality: quality,
+          scale: scale,
           timeout: timeout,
           type: type,
         }.compact

data/lib/playwright/channel_owners/frame.rb

@@ -25,11 +25,25 @@ module Playwright
     private def on_load_state(add:, remove:)
       if add
         @load_states << add
-        @event_emitter.emit('loadstate', add)
+
+        # Original JS version of Playwright emit event here.
+        # @event_emitter.emit('loadstate', add)
       end
       if remove
         @load_states.delete(remove)
       end
+      unless @parent_frame
+        if add == 'load'
+          @page&.emit(Events::Page::Load, @page)
+        elsif add == 'domcontentloaded'
+          @page&.emit(Events::Page::DOMContentLoaded, @page)
+        end
+      end
+
+      # emit to waitForLoadState(load) listeners explicitly after waitForEvent(load) listeners
+      if add
+        @event_emitter.emit('loadstate', add)
+      end
     end
 
     private def on_frame_navigated(event)
@@ -38,7 +52,7 @@ module Playwright
       @event_emitter.emit('navigated', event)
 
       unless event['error']
-        @page&.emit('framenavigated', self)
+        @page&.emit(Events::Page::FrameNavigated, self)
       end
     end
 
@@ -487,15 +501,14 @@ module Playwright
     end
 
     def set_input_files(selector, files, noWaitAfter: nil, strict: nil, timeout: nil)
-      file_payloads = InputFiles.new(files).as_params
-      params = {
-        files: file_payloads,
+      method_name, params = InputFiles.new(page.context, files).as_method_and_params
+      params.merge!({
         selector: selector,
         noWaitAfter: noWaitAfter,
         strict: strict,
         timeout: timeout,
-      }.compact
-      @channel.send_message_to_server('setInputFiles', params)
+      }.compact)
+      @channel.send_message_to_server(method_name, params)
 
       nil
     end

data/lib/playwright/channel_owners/local_utils.rb

@@ -10,5 +10,34 @@ module Playwright
       @channel.send_message_to_server('zip', params)
       nil
     end
+
+
+    # @param file [String]
+    # @return [String] har ID
+    def har_open(file)
+      @channel.send_message_to_server('harOpen', file: file)
+    end
+
+    def har_lookup(har_id:, url:, method:, headers:, is_navigation_request:, post_data: nil)
+      params = {
+        harId: har_id,
+        url: url,
+        method: method,
+        headers: headers,
+        postData: post_data,
+        isNavigationRequest: is_navigation_request,
+      }.compact
+
+      @channel.send_message_to_server_result('harLookup', params)
+    end
+
+    # @param har_id [String]
+    def async_har_close(har_id)
+      @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)
+    end
   end
 end

data/lib/playwright/channel_owners/page.rb

@@ -39,7 +39,6 @@ module Playwright
       })
       @channel.on('crash', ->(_) { emit(Events::Page::Crash) })
       @channel.on('dialog', method(:on_dialog))
-      @channel.on('domcontentloaded', ->(_) { emit(Events::Page::DOMContentLoaded) })
       @channel.on('download', method(:on_download))
       @channel.on('fileChooser', ->(params) {
         chooser = FileChooserImpl.new(
@@ -54,12 +53,15 @@ module Playwright
       @channel.on('frameDetached', ->(params) {
         on_frame_detached(ChannelOwners::Frame.from(params['frame']))
       })
-      @channel.on('load', ->(_) { emit(Events::Page::Load) })
       @channel.on('pageError', ->(params) {
         emit(Events::Page::PageError, Error.parse(params['error']['error']))
       })
       @channel.on('route', ->(params) {
-        on_route(ChannelOwners::Route.from(params['route']), ChannelOwners::Request.from(params['request']))
+        Concurrent::Promises.future {
+          on_route(ChannelOwners::Route.from(params['route']), ChannelOwners::Request.from(params['request']))
+        }.rescue do |err|
+          puts err, err.backtrace
+        end
       })
       @channel.on('video', method(:on_video))
       @channel.on('webSocket', ->(params) {
@@ -98,18 +100,26 @@ module Playwright
       wrapped_route = PlaywrightApi.wrap(route)
       wrapped_request = PlaywrightApi.wrap(request)
 
-      handler_entry = @routes.find do |entry|
-        entry.match?(request.url)
+      handled = @routes.any? do |handler_entry|
+        next false unless handler_entry.match?(request.url)
+
+        promise = Concurrent::Promises.resolvable_future
+        route.send(:set_handling_future, promise)
+
+        promise_handled = Concurrent::Promises.zip(
+          promise,
+          handler_entry.async_handle(wrapped_route, wrapped_request)
+        ).value!.first
+
+        promise_handled
       end
 
-      if handler_entry
-        handler_entry.async_handle(wrapped_route, wrapped_request)
+      @routes.reject!(&:expired?)
+      if @routes.count == 0
+        @channel.async_send_message_to_server('setNetworkInterceptionEnabled', enabled: false)
+      end
 
-        @routes.reject!(&:expired?)
-        if @routes.count == 0
-          @channel.async_send_message_to_server('setNetworkInterceptionEnabled', enabled: false)
-        end
-      else
+      unless handled
         @browser_context.send(:on_route, route, request)
       end
     end
@@ -407,16 +417,33 @@ module Playwright
       end
     end
 
+    def route_from_har(har, notFound: nil, update: nil, url: nil)
+      if update
+        @browser_context.send(:record_into_har, har, self, notFound: notFound, url: url)
+        return
+      end
+
+      router = HarRouter.create(
+        @connection.local_utils,
+        har.to_s,
+        notFound || "abort",
+        url_match: url,
+      )
+      router.add_page_route(self)
+    end
+
     def screenshot(
-      path: nil,
-      type: nil,
-      quality: nil,
-      fullPage: nil,
-      clip: nil,
-      omitBackground: nil,
       animations: nil,
+      caret: nil,
+      clip: nil,
+      fullPage: nil,
       mask: nil,
-      timeout: nil)
+      omitBackground: nil,
+      path: nil,
+      quality: nil,
+      scale: nil,
+      timeout: nil,
+      type: nil)
 
       params = {
         type: type,
@@ -425,6 +452,8 @@ module Playwright
         clip: clip,
         omitBackground: omitBackground,
         animations: animations,
+        caret: caret,
+        scale: scale,
         timeout: timeout,
       }.compact
       if mask.is_a?(Enumerable)
@@ -447,9 +476,12 @@ module Playwright
     end
 
     def close(runBeforeUnload: nil)
-      options = { runBeforeUnload: runBeforeUnload }.compact
-      @channel.send_message_to_server('close', options)
-      @owned_context&.close
+      if @owned_context
+        @owned_context.close
+      else
+        options = { runBeforeUnload: runBeforeUnload }.compact
+        @channel.send_message_to_server('close', options)
+      end
       nil
     rescue => err
       raise unless safe_close_error?(err)

data/lib/playwright/channel_owners/request.rb

@@ -18,10 +18,24 @@ module Playwright
         responseStart: -1,
         responseEnd: -1,
       }
+      @fallback_overrides = {}
+    end
+
+    private def fallback_overrides
+      @fallback_overrides
+    end
+
+    def apply_fallback_overrides(overrides)
+      allowed_key = %i[url method headers postData]
+      overrides.each do |key, value|
+        raise ArgumentError.new("invalid key: #{key}") unless allowed_key.include?(key)
+        @fallback_overrides[key] = value
+      end
+      @fallback_overrides
     end
 
     def url
-      @initializer['url']
+      @fallback_overrides[:url] || @initializer['url']
     end
 
     def resource_type
@@ -29,7 +43,7 @@ module Playwright
     end
 
     def method
-      @initializer['method']
+      @fallback_overrides[:method] || @initializer['method']
     end
 
     def post_data
@@ -51,8 +65,11 @@ module Playwright
     end
 
     def post_data_buffer
-      base64_content = @initializer['postData']
-      if base64_content
+      if (override = @fallback_overrides[:postData])
+        return override
+      end
+
+      if (base64_content = @initializer['postData'])
         Base64.strict_decode64(base64_content)
       else
         nil
@@ -79,12 +96,20 @@ module Playwright
     attr_reader :redirected_from, :redirected_to, :timing
 
     def headers
-      @provisional_headers.headers
+      if (override = @fallback_overrides[:headers])
+        RawHeaders.new(HttpHeaders.new(override).as_serialized).headers
+      else
+        @provisional_headers.headers
+      end
     end
 
     # @return [RawHeaders|nil]
     private def actual_headers
-      @actual_headers ||= raw_request_headers
+      if (override = @fallback_overrides[:headers])
+        RawHeaders.new(HttpHeaders.new(override).as_serialized)
+      else
+        @actual_headers ||= raw_request_headers
+      end
     end
 
     private def raw_request_headers

data/lib/playwright/channel_owners/response.rb

@@ -52,6 +52,12 @@ module Playwright
       RawHeaders.new(@channel.send_message_to_server('rawResponseHeaders'))
     end
 
+    def from_service_worker
+      @initializer['fromServiceWorker']
+    end
+
+    alias_method :from_service_worker?, :from_service_worker
+
     def all_headers
       actual_headers.headers
     end