playwright-ruby-client 1.22.0 → 1.23.0

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,6 +417,21 @@ 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(
       animations: nil,
       caret: nil,
@@ -451,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

data/lib/playwright/channel_owners/route.rb

@@ -3,13 +3,28 @@ require 'mime/types'
 
 module Playwright
   define_channel_owner :Route do
+    private def set_handling_future(future)
+      @handling_future = future
+    end
+
+    private def handling_with_result(done, &block)
+      chain = @handling_future
+      raise 'Route is already handled!' unless chain
+      block.call
+      @handling_future = nil
+      chain.fulfill(done)
+    end
+
     def request
       ChannelOwners::Request.from(@initializer['request'])
     end
 
     def abort(errorCode: nil)
-      params = { errorCode: errorCode }.compact
-      @channel.async_send_message_to_server('abort', params)
+      handling_with_result(true) do
+        params = { errorCode: errorCode }.compact
+        # TODO _race_with_page_close
+        @channel.async_send_message_to_server('abort', params)
+      end
     end
 
     def fulfill(
@@ -19,69 +34,113 @@ module Playwright
           path: nil,
           status: nil,
           response: nil)
-      params = {
-        contentType: contentType,
-        status: status,
-      }.compact
-      option_body = body
+      handling_with_result(true) do
+        params = {
+          contentType: contentType,
+          status: status,
+        }.compact
+        option_body = body
 
-      if response
-        params[:status] ||= response.status
-        params[:headers] ||= response.headers
+        if response
+          params[:status] ||= response.status
+          params[:headers] ||= response.headers
 
-        if !body && !path && response.is_a?(APIResponse)
-          if response.send(:_request).send(:same_connection?, self)
-            params[:fetchResponseUid] = response.send(:fetch_uid)
-          else
-            option_body = response.body
+          if !body && !path && response.is_a?(APIResponse)
+            if response.send(:_request).send(:same_connection?, self)
+              params[:fetchResponseUid] = response.send(:fetch_uid)
+            else
+              option_body = response.body
+            end
           end
         end
-      end
 
-      content =
-        if option_body
-          option_body
+        content =
+          if option_body
+            option_body
+          elsif path
+            File.read(path)
+          else
+            nil
+          end
+
+        param_headers = headers || {}
+        if contentType
+          param_headers['content-type'] = contentType
         elsif path
-          File.read(path)
-        else
-          nil
+          param_headers['content-type'] = mime_type_for(path)
         end
 
-      param_headers = headers || {}
-      if contentType
-        param_headers['content-type'] = contentType
-      elsif path
-        param_headers['content-type'] = mime_type_for(path)
-      end
-
-      if content
-        if content.is_a?(String)
-          params[:body] = content
-          params[:isBase64] = false
-        else
-          params[:body] = Base64.strict_encode64(content)
-          params[:isBase64] = true
+        if content
+          if content.is_a?(String)
+            params[:body] = content
+            params[:isBase64] = false
+          else
+            params[:body] = Base64.strict_encode64(content)
+            params[:isBase64] = true
+          end
+          param_headers['content-length'] ||= content.length.to_s
         end
-        param_headers['content-length'] ||= content.length.to_s
+
+        params[:headers] = HttpHeaders.new(param_headers).as_serialized
+
+        @channel.async_send_message_to_server('fulfill', params)
       end
+    end
 
-      params[:headers] = HttpHeaders.new(param_headers).as_serialized
+    def fallback(headers: nil, method: nil, postData: nil, url: nil)
+      overrides = {
+        headers: headers,
+        method: method,
+        postData: postData,
+        url: url,
+      }.compact
 
-      @channel.async_send_message_to_server('fulfill', params)
+      handling_with_result(false) do
+        request.apply_fallback_overrides(overrides)
+      end
     end
 
     def continue(headers: nil, method: nil, postData: nil, url: nil)
-      overrides = { url: url, method: method }.compact
+      overrides = {
+        headers: headers,
+        method: method,
+        postData: postData,
+        url: url,
+      }.compact
 
-      if headers
-        overrides[:headers] = HttpHeaders.new(headers).as_serialized
+      handling_with_result(true) do
+        request.apply_fallback_overrides(overrides)
+        async_continue_route
       end
+    end
 
-      if postData
-        overrides[:postData] = Base64.strict_encode64(postData)
+    private def async_continue_route
+      post_data_for_wire =
+        if (post_data_from_overrides = request.send(:fallback_overrides)[:postData])
+          post_data_for_wire = Base64.strict_encode64(post_data_from_overrides)
+        else
+          nil
+        end
+
+      params = request.send(:fallback_overrides).dup
+
+      if params[:headers]
+        params[:headers] = HttpHeaders.new(params[:headers]).as_serialized
+      end
+
+      if post_data_for_wire
+        params[:postData] = post_data_for_wire
       end
 
-      @channel.async_send_message_to_server('continue', overrides)
+      # TODO _race_with_page_close
+      @channel.async_send_message_to_server('continue', params)
+    end
+
+    def redirect_navigation_request(url)
+      handling_with_result(true) do
+        # TODO _race_with_page_close
+        @channel.send_message_to_server('redirectNavigationRequest', { url: url })
+      end
     end
 
     private def mime_type_for(filepath)

data/lib/playwright/connection.rb

@@ -24,6 +24,8 @@ module Playwright
       @remote = false
     end
 
+    attr_reader :local_utils
+
     def mark_as_remote
       @remote = true
     end
@@ -127,12 +129,15 @@ module Playwright
       params = msg['params']
 
       if method == "__create__"
-        create_remote_object(
+        remote_object = create_remote_object(
           parent_guid: guid,
           type: params["type"],
           guid: params["guid"],
           initializer: params["initializer"],
         )
+        if remote_object.is_a?(ChannelOwners::LocalUtils)
+          @local_utils = remote_object
+        end
         return
       end
 

data/lib/playwright/har_router.rb

@@ -0,0 +1,82 @@
+module Playwright
+  class HarRouter
+    # @param local_utils [LocalUtils]
+    # @param file [String]
+    # @param not_found_action [String] 'abort' or 'fallback'
+    # @param url_match [String||Regexp|nil]
+    def self.create(local_utils, file, not_found_action, url_match: nil)
+      har_id = local_utils.har_open(file)
+
+      new(
+        local_utils: local_utils,
+        har_id: har_id,
+        not_found_action: not_found_action,
+        url_match: url_match,
+      )
+    end
+
+    # @param local_utils [LocalUtils]
+    # @param har_id [String]
+    # @param not_found_action [String] 'abort' or 'fallback'
+    # @param url_match [String||Regexp|nil]
+    def initialize(local_utils:, har_id:, not_found_action:,  url_match: nil)
+      unless ['abort', 'fallback'].include?(not_found_action)
+        raise ArgumentError.new("not_found_action must be either 'abort' or 'fallback'. '#{not_found_action}' is specified.")
+      end
+
+      @local_utils = local_utils
+      @har_id = har_id
+      @not_found_action = not_found_action
+      @url_match = url_match || '**/*'
+      @debug = ENV['DEBUG'].to_s == 'true' || ENV['DEBUG'].to_s == '1'
+    end
+
+    private def handle(route, request)
+      response = @local_utils.har_lookup(
+        har_id: @har_id,
+        url: request.url,
+        method: request.method,
+        headers: request.headers_array,
+        post_data: request.post_data_buffer,
+        is_navigation_request: request.navigation_request?,
+      )
+      case response['action']
+      when 'redirect'
+        redirect_url = response['redirectURL']
+        puts "pw:api HAR: #{request.url} redirected to #{redirect_url}" if @debug
+        route.redirect_navigation_request(redirect_url)
+      when 'fulfill'
+        route.fulfill(
+          status: response['status'],
+          headers: response['headers'].map { |header| [header['name'], header['value']] }.to_h,
+          body: Base64.strict_decode64(response['body']),
+        )
+      else
+        # Report the error, but fall through to the default handler.
+        if response['action'] == 'error'
+          puts "pw:api HAR: #{response['message']} redirected to #{redirect_url}" if @debug
+        end
+
+        if @not_found_action == 'abort'
+          route.abort
+        else
+          route.fallback
+        end
+      end
+    end
+
+    def add_context_route(context)
+      context.route(@url_match, method(:handle))
+      context.once(Events::BrowserContext::Close, method(:dispose))
+    end
+
+    def add_page_route(page)
+      page.route(@url_match, method(:handle))
+      page.once(Events::Page::Close, method(:dispose))
+    end
+
+    def dispose
+      @local_utils.async_har_close(@har_id)
+    end
+  end
+end

data/lib/playwright/http_headers.rb

@@ -7,7 +7,7 @@ module Playwright
 
     def as_serialized
       @headers.map do |key, value|
-        { name: key, value: value }
+        { 'name' => key, 'value' => value }
       end
     end
   end

data/lib/playwright/javascript/regex.rb

@@ -0,0 +1,23 @@
+module Playwright
+  module JavaScript
+    class Regex
+      def initialize(regexp)
+        unless regexp.is_a?(Regexp)
+          raise ArgumentError("Argument must be a Regexp: #{regexp} (#{regexp.class})")
+        end
+
+        @source = regexp.source
+        @flag = flag_for(regexp)
+      end
+
+      attr_reader :source, :flag
+
+      private def flag_for(regexp)
+        flags = []
+        flags << 'ms' if (regexp.options & Regexp::MULTILINE) != 0
+        flags << 'i' if (regexp.options & Regexp::IGNORECASE) != 0
+        flags.join('')
+      end
+    end
+  end
+end

data/lib/playwright/javascript/value_serializer.rb

@@ -1,4 +1,5 @@
 require_relative './visitor_info'
+require_relative './regex'
 
 module Playwright
   module JavaScript
@@ -40,10 +41,8 @@ module Playwright
           require 'time'
           { d: value.utc.iso8601 }
         when Regexp
-          flags = []
-          flags << 'ms' if (value.options & Regexp::MULTILINE) != 0
-          flags << 'i' if (value.options & Regexp::IGNORECASE) != 0
-          { r: { p: value.source, f: flags.join('') } }
+          regex_value = Regex.new(value)
+          { r: { p: regex_value.source, f: regex_value.flag } }
         when -> (value) { @visited.ref(value) }
           { ref: @visited.ref(value) }
         when Array

data/lib/playwright/javascript.rb

@@ -1,3 +1,4 @@
 require_relative './javascript/expression'
 require_relative './javascript/value_parser'
 require_relative './javascript/value_serializer'
+require_relative './javascript/regex'

data/lib/playwright/locator_impl.rb

@@ -31,11 +31,9 @@ module Playwright
 
       case hasText
       when Regexp
-        source = EscapeWithQuotes.new(hasText.source, '"')
-        flags = []
-        flags << 'ms' if (hasText.options & Regexp::MULTILINE) != 0
-        flags << 'i' if (hasText.options & Regexp::IGNORECASE) != 0
-        selector_scopes << ":scope:text-matches(#{source}, \"#{flags.join('')}\")"
+        regex = JavaScript::Regex.new(hasText)
+        source = EscapeWithQuotes.new(regex.source, '"')
+        selector_scopes << ":scope:text-matches(#{source}, \"#{regex.flag}\")"
       when String
         text = EscapeWithQuotes.new(hasText, '"')
         selector_scopes << ":scope:has-text(#{text})"

data/lib/playwright/route_handler.rb

@@ -50,12 +50,8 @@ module Playwright
     def async_handle(route, request)
       @counter.increment
 
-      Concurrent::Promises.future do
-        begin
-          @handler.call(route, request)
-        rescue => err
-          puts err, err.backtrace
-        end
+      Concurrent::Promises.future { @handler.call(route, request) }.rescue do |err|
+        puts err, err.backtrace
       end
     end
 

data/lib/playwright/utils.rb

@@ -1,6 +1,36 @@
 module Playwright
   module Utils
     module PrepareBrowserContextOptions
+      private def prepare_record_har_options(params)
+        out_params = {
+          path: params.delete(:record_har_path)
+        }
+        if params[:record_har_url_filter]
+          opt = params.delete(:record_har_url_filter)
+          if opt.is_a?(Regexp)
+            regex = ::Playwright::JavaScript::Regex.new(opt)
+            out_params[:urlRegexSource] = regex.source
+            out_params[:urlRegexFlags] = regex.flag
+          elsif opt.is_a?(String)
+            out_params[:urlGlob] = opt
+          end
+        end
+        if params[:record_har_mode]
+          out_params[:mode] = params.delete(:record_har_mode)
+        end
+        if params[:record_har_content]
+          out_params[:content] = params.delete(:record_har_content)
+        end
+        if params[:record_har_omit_content]
+          old_api_omit_content = params.delete(:record_har_omit_content)
+          if old_api_omit_content
+            out_params[:content] ||= 'omit'
+          end
+        end
+
+        out_params
+      end
+
       # @see https://github.com/microsoft/playwright/blob/5a2cfdbd47ed3c3deff77bb73e5fac34241f649d/src/client/browserContext.ts#L265
       private def prepare_browser_context_options(params)
         if params[:noViewport] == 0
@@ -11,12 +41,7 @@ module Playwright
           params[:extraHTTPHeaders] = ::Playwright::HttpHeaders.new(params[:extraHTTPHeaders]).as_serialized
         end
         if params[:record_har_path]
-          params[:recordHar] = {
-            path: params.delete(:record_har_path)
-          }
-          if params[:record_har_omit_content]
-            params[:recordHar][:omitContent] = params.delete(:record_har_omit_content)
-          end
+          params[:recordHar] = prepare_record_har_options(params)
         end
         if params[:record_video_dir]
           params[:recordVideo] = {

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '1.22.0'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.22.1'
+  VERSION = '1.23.0'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.23.4'
 end

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/har_router'
 require 'playwright/raw_headers'
 require 'playwright/route_handler'
 require 'playwright/select_option_values'
@@ -143,6 +144,7 @@ module Playwright
         playwright = connection.initialize_playwright
         browser = playwright.send(:pre_launched_browser)
         browser.should_close_connection_on_close!
+        browser.send(:update_browser_type, browser.browser_type)
         Execution.new(connection, PlaywrightApi.wrap(playwright), PlaywrightApi.wrap(browser))
       rescue
         connection.stop

data/lib/playwright_api/android_device.rb

@@ -57,18 +57,22 @@ module Playwright
           noViewport: nil,
           offline: nil,
           permissions: nil,
+          record_har_content: nil,
+          record_har_mode: nil,
           record_har_omit_content: nil,
           record_har_path: nil,
+          record_har_url_filter: nil,
           record_video_dir: nil,
           record_video_size: nil,
           reducedMotion: nil,
           screen: nil,
+          serviceWorkers: nil,
           strictSelectors: nil,
           timezoneId: nil,
           userAgent: nil,
           viewport: nil,
           &block)
-      wrap_impl(@impl.launch_browser(acceptDownloads: unwrap_impl(acceptDownloads), baseURL: unwrap_impl(baseURL), bypassCSP: unwrap_impl(bypassCSP), colorScheme: unwrap_impl(colorScheme), command: unwrap_impl(command), deviceScaleFactor: unwrap_impl(deviceScaleFactor), extraHTTPHeaders: unwrap_impl(extraHTTPHeaders), forcedColors: unwrap_impl(forcedColors), geolocation: unwrap_impl(geolocation), hasTouch: unwrap_impl(hasTouch), httpCredentials: unwrap_impl(httpCredentials), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), isMobile: unwrap_impl(isMobile), javaScriptEnabled: unwrap_impl(javaScriptEnabled), locale: unwrap_impl(locale), noViewport: unwrap_impl(noViewport), offline: unwrap_impl(offline), permissions: unwrap_impl(permissions), record_har_omit_content: unwrap_impl(record_har_omit_content), record_har_path: unwrap_impl(record_har_path), record_video_dir: unwrap_impl(record_video_dir), record_video_size: unwrap_impl(record_video_size), reducedMotion: unwrap_impl(reducedMotion), screen: unwrap_impl(screen), strictSelectors: unwrap_impl(strictSelectors), timezoneId: unwrap_impl(timezoneId), userAgent: unwrap_impl(userAgent), viewport: unwrap_impl(viewport), &wrap_block_call(block)))
+      wrap_impl(@impl.launch_browser(acceptDownloads: unwrap_impl(acceptDownloads), baseURL: unwrap_impl(baseURL), bypassCSP: unwrap_impl(bypassCSP), colorScheme: unwrap_impl(colorScheme), command: unwrap_impl(command), deviceScaleFactor: unwrap_impl(deviceScaleFactor), extraHTTPHeaders: unwrap_impl(extraHTTPHeaders), forcedColors: unwrap_impl(forcedColors), geolocation: unwrap_impl(geolocation), hasTouch: unwrap_impl(hasTouch), httpCredentials: unwrap_impl(httpCredentials), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), isMobile: unwrap_impl(isMobile), javaScriptEnabled: unwrap_impl(javaScriptEnabled), locale: unwrap_impl(locale), noViewport: unwrap_impl(noViewport), offline: unwrap_impl(offline), permissions: unwrap_impl(permissions), record_har_content: unwrap_impl(record_har_content), record_har_mode: unwrap_impl(record_har_mode), record_har_omit_content: unwrap_impl(record_har_omit_content), record_har_path: unwrap_impl(record_har_path), record_har_url_filter: unwrap_impl(record_har_url_filter), record_video_dir: unwrap_impl(record_video_dir), record_video_size: unwrap_impl(record_video_size), reducedMotion: unwrap_impl(reducedMotion), screen: unwrap_impl(screen), serviceWorkers: unwrap_impl(serviceWorkers), strictSelectors: unwrap_impl(strictSelectors), timezoneId: unwrap_impl(timezoneId), userAgent: unwrap_impl(userAgent), viewport: unwrap_impl(viewport), &wrap_block_call(block)))
     end
 
     # Performs a long tap on the widget defined by `selector`.