playwright-ruby-client 0.0.8 → 1.58.1.alpha1

data/lib/playwright/test.rb

@@ -0,0 +1,102 @@
+module Playwright
+  # this module is responsible for running playwright assertions and integrating
+  # with test frameworks.
+  module Test
+    @@expect_timeout = nil
+
+    def self.expect_timeout
+      @@expect_timeout || 5000 # default timeout is 5000ms
+    end
+
+    def self.expect_timeout=(timeout)
+      @@expect_timeout = timeout
+    end
+
+    def self.with_timeout(expect_timeout, &block)
+      old_timeout = @@expect_timeout
+      @@expect_timeout = expect_timeout
+      block.call
+    ensure
+      @@expect_timeout = old_timeout
+    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)
+          @method = expectation_method
+          @args = args
+          @kwargs = kwargs
+        end
+
+        def matches?(actual)
+          Expect.new.call(actual, false).send(@method, *@args, **@kwargs)
+          true
+        rescue AssertionError => e
+          @failure_message = e.full_message
+          false
+        end
+
+        def does_not_match?(actual)
+          Expect.new.call(actual, true).send(@method, *@args, **@kwargs)
+          true
+        rescue AssertionError => e
+          @failure_message = e.full_message
+          false
+        end
+
+        def failure_message
+          @failure_message
+        end
+
+        def failure_message_when_negated
+          @failure_message
+        end
+      end
+    end
+
+    ALL_ASSERTIONS = PageAssertions.instance_methods(false) + LocatorAssertions.instance_methods(false)
+
+    ALL_ASSERTIONS
+      .map(&:to_s)
+      .each do |method_name|
+        # to_be_visible => be_visible
+        # not_to_be_visible => not_be_visible
+        root_method_name = method_name.gsub("to_", "")
+        Matchers.send(:define_method, root_method_name) do |*args, **kwargs|
+          Matchers::PlaywrightMatcher.new(method_name, *args, **kwargs)
+        end
+      end
+  end
+end

data/lib/playwright/timeout_settings.rb

@@ -1,6 +1,7 @@
 module Playwright
   class TimeoutSettings
     DEFAULT_TIMEOUT = 30000
+    DEFAULT_LAUNCH_TIMEOUT = 180000 # 3 minutes
 
     def initialize(parent = nil)
       @parent = parent
@@ -8,12 +9,16 @@ module Playwright
 
     attr_writer :default_timeout, :default_navigation_timeout
 
-    def navigation_timeout
-      @default_navigation_timeout || @default_timeout || @parent&.navigation_timeout || DEFAULT_TIMEOUT
+    def navigation_timeout(timeout_override = nil)
+      timeout_override || @default_navigation_timeout || @default_timeout || @parent&.navigation_timeout || DEFAULT_TIMEOUT
     end
 
-    def timeout
-      @default_timeout || @parent&.timeout || DEFAULT_TIMEOUT
+    def timeout(timeout_override = nil)
+      timeout_override || @default_timeout || @parent&.timeout || DEFAULT_TIMEOUT
+    end
+
+    def launch_timeout(timeout_override = nil)
+      timeout_override || @default_timeout || @parent&.launch_timeout || DEFAULT_LAUNCH_TIMEOUT
     end
   end
 end

data/lib/playwright/touchscreen_impl.rb

@@ -0,0 +1,14 @@
+module Playwright
+  define_api_implementation :TouchscreenImpl do
+    def initialize(channel)
+      @channel = channel
+    end
+
+    def tap_point(x, y)
+      @channel.send_message_to_server('touchscreenTap', {
+        x: x,
+        y: y,
+      })
+    end
+  end
+end

data/lib/playwright/transport.rb

@@ -8,47 +8,69 @@ module Playwright
   # ref: https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_transport.py
   class Transport
     # @param playwright_cli_executable_path [String] path to playwright-cli.
-    # @param debug [Boolean]
     def initialize(playwright_cli_executable_path:)
       @driver_executable_path = playwright_cli_executable_path
       @debug = ENV['DEBUG'].to_s == 'true' || ENV['DEBUG'].to_s == '1'
+      @mutex = Mutex.new
     end
 
     def on_message_received(&block)
       @on_message = block
     end
 
+    def on_driver_closed(&block)
+      @on_driver_closed = block
+    end
+
+    def on_driver_crashed(&block)
+      @on_driver_crashed = block
+    end
+
     class AlreadyDisconnectedError < StandardError ; end
 
     # @param message [Hash]
     def send_message(message)
       debug_send_message(message) if @debug
       msg = JSON.dump(message)
-      @stdin.write([msg.size].pack('V')) # unsigned 32bit, little endian
-      @stdin.write(msg)
-    rescue Errno::EPIPE
+      @mutex.synchronize {
+        @stdin.write([msg.bytes.length].pack('V')) # unsigned 32bit, little endian, real byte size instead of chars
+        @stdin.write(msg) # write UTF-8 in binary mode as byte stream
+      }
+    rescue Errno::EPIPE, IOError
       raise AlreadyDisconnectedError.new('send_message failed')
     end
 
     # Terminate playwright-cli driver.
     def stop
       [@stdin, @stdout, @stderr].each { |io| io.close unless io.closed? }
+      @thread&.join
     end
 
     # Start `playwright-cli run-driver`
     #
     # @note This method blocks until playwright-cli exited. Consider using Thread or Future.
-    def run
-      @stdin, @stdout, @stderr, @thread = Open3.popen3(@driver_executable_path, 'run-driver')
+    def async_run
+      @stdin, @stdout, @stderr, @thread = run_driver_with_open3
+      @stdin.binmode  # Ensure Strings are written 1:1 without encoding conversion, necessary for integer values
 
       Thread.new { handle_stdout }
       Thread.new { handle_stderr }
-
-      @thread.join
     end
 
     private
 
+    def run_driver_with_open3
+      Open3.popen3("#{@driver_executable_path} run-driver", { pgroup: true })
+    rescue ArgumentError => err
+      # Windows doesn't accept pgroup parameter.
+      # ArgumentError: wrong exec option symbol: pgroup
+      if err.message =~ /pgroup/
+        Open3.popen3("#{@driver_executable_path} run-driver")
+      else
+        raise
+      end
+    end
+
     def handle_stdout(packet_size: 32_768)
       while chunk = @stdout.read(4)
         length = chunk.unpack1('V') # unsigned 32bit, little endian
@@ -65,22 +87,51 @@ module Playwright
       end
     rescue IOError
       # disconnected by remote.
+      @on_driver_closed&.call
     end
 
     def handle_stderr
       while err = @stderr.read
+        # sometimed driver crashes with the error below.
+        # --------
+        # undefined:1
+        # �
+        # ^
+
+        # SyntaxError: Unexpected token � in JSON at position 0
+        #     at JSON.parse (<anonymous>)
+        #     at Transport.transport.onmessage (/home/runner/work/playwright-ruby-client/playwright-ruby-client/node_modules/playwright/lib/cli/driver.js:42:73)
+        #     at Immediate.<anonymous> (/home/runner/work/playwright-ruby-client/playwright-ruby-client/node_modules/playwright/lib/protocol/transport.js:74:26)
+        #     at processImmediate (internal/timers.js:461:21)
+        if err.include?('undefined:1')
+          @on_driver_crashed&.call
+          break
+        end
         $stderr.write(err)
       end
     rescue IOError
       # disconnected by remote.
+      @on_driver_closed&.call
     end
 
     def debug_send_message(message)
-      puts "\x1b[33mSEND>\x1b[0m#{message}"
+      metadata = message.delete(:metadata)
+      puts "\x1b[33mSEND>\x1b[0m#{shorten_double_quoted_string(message)}"
+      message[:metadata] = metadata
     end
 
     def debug_recv_message(message)
-      puts "\x1b[33mRECV>\x1b[0m#{message}"
+      puts "\x1b[33mRECV>\x1b[0m#{shorten_double_quoted_string(message)}"
+    end
+
+    def shorten_double_quoted_string(message, maxlen: 512)
+      message.to_s.gsub(/"([^"]+)"/) do |str|
+        if $1.length > maxlen
+          "\"#{$1[0...maxlen]}...\""
+        else
+          str
+        end
+      end
     end
   end
 end

data/lib/playwright/url_matcher.rb

@@ -1,19 +1,41 @@
 module Playwright
   class UrlMatcher
     # @param url [String|Regexp]
-    def initialize(url)
+    # @param base_url [String|nil]
+    def initialize(url, base_url:)
       @url = url
+      @base_url = base_url
+    end
+
+    def as_pattern
+      case @url
+      when String
+        { glob: @url }
+      when Regexp
+        regex = JavaScript::Regex.new(@url)
+        { regexSource: regex.source, regexFlags: regex.flag }
+      else
+        nil
+      end
     end
 
     def match?(target_url)
       case @url
       when String
-        @url == target_url
+        joined_url == target_url || File.fnmatch?(@url, target_url)
       when Regexp
         @url.match?(target_url)
       else
         false
       end
     end
+
+    private def joined_url
+      if @base_url && !@url.start_with?('*')
+        URI.join(@base_url, @url).to_s
+      else
+        @url
+      end
+    end
   end
 end

data/lib/playwright/utils.rb

@@ -1,35 +1,70 @@
+require 'base64'
+
 module Playwright
   module Utils
     module PrepareBrowserContextOptions
       # @see https://github.com/microsoft/playwright/blob/5a2cfdbd47ed3c3deff77bb73e5fac34241f649d/src/client/browserContext.ts#L265
       private def prepare_browser_context_options(params)
-        if params[:viewport] == 0
-          params.delete(:viewport)
+        if params[:noViewport] == 0
+          params.delete(:noViewport)
           params[:noDefaultViewport] = true
         end
         if params[:extraHTTPHeaders]
-          # TODO
+          params[:extraHTTPHeaders] = ::Playwright::HttpHeaders.new(params[:extraHTTPHeaders]).as_serialized
+        end
+        if params[:record_video_dir]
+          params[:recordVideo] = {
+            dir: params.delete(:record_video_dir)
+          }
+          if params[:record_video_size]
+            params[:recordVideo][:size] = params.delete(:record_video_size)
+          end
         end
         if params[:storageState].is_a?(String)
           params[:storageState] = JSON.parse(File.read(params[:storageState]))
         end
 
+        %i[colorScheme reducedMotion forcedColors contrast].each do |key|
+          if params[key] == 'null'
+            params[key] = 'no-override'
+          end
+        end
+
+        if params[:acceptDownloads] || params[:acceptDownloads] == false
+          params[:acceptDownloads] = params[:acceptDownloads] ? 'accept' : 'deny'
+        end
+
+        if params[:clientCertificates].is_a?(Array)
+          params[:clientCertificates] = params[:clientCertificates].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
+
         params
       end
     end
 
     module Errors
-      module SafeCloseError
+      module TargetClosedErrorMethods
         # @param err [Exception]
-        private def safe_close_error?(err)
-          return true if err.is_a?(Transport::AlreadyDisconnectedError)
-
-          [
-            'Browser has been closed',
-            'Target page, context or browser has been closed',
-          ].any? do |closed_message|
-            err.message.end_with?(closed_message)
-          end
+        private def target_closed_error?(err)
+          err.is_a?(TargetClosedError)
         end
       end
     end

data/lib/playwright/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '0.0.8'
+  VERSION = '1.58.1.alpha1'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.58.0'
 end

data/lib/playwright/video.rb

@@ -0,0 +1,54 @@
+module Playwright
+  class Video
+    def initialize(page)
+      @page = page
+      @artifact = Concurrent::Promises.resolvable_future
+      if @page.closed?
+        on_page_closed
+      else
+        page.once('close', -> { on_page_closed })
+      end
+    end
+
+    private def on_page_closed
+      unless @artifact.resolved?
+        @artifact.reject('Page closed')
+      end
+    end
+
+    # called only from Page#on_video via send(:set_artifact, artifact)
+    private def set_artifact(artifact)
+      @artifact.fulfill(artifact)
+    end
+
+    def path
+      if @page.send(:remote_connection?)
+        raise 'Path is not available when using browserType.connect(). Use save_as() to save a local copy.'
+      end
+      wait_for_artifact_and do |artifact|
+        artifact.absolute_path
+      end
+    end
+
+    def save_as(path)
+      wait_for_artifact_and do |artifact|
+        artifact.save_as(path)
+      end
+    end
+
+    def delete
+      wait_for_artifact_and do |artifact|
+        artifact.delete
+      end
+    end
+
+    private def wait_for_artifact_and(&block)
+      artifact = @artifact.value!
+      unless artifact
+        raise 'Page did not produce any video frames'
+      end
+
+      block.call(artifact)
+    end
+  end
+end

data/lib/playwright/waiter.rb

@@ -0,0 +1,166 @@
+require 'securerandom'
+
+module Playwright
+  # ref: https://github.com/microsoft/playwright-python/blob/v1.40.0/playwright/_impl/_waiter.py
+  # ref: https://github.com/microsoft/playwright/blob/v1.40.0/packages/playwright-core/src/client/waiter.ts
+  class Waiter
+    def initialize(channel_owner, wait_name:)
+      @result = Concurrent::Promises.resolvable_future
+      @wait_id = SecureRandom.hex(16)
+      @event = wait_name
+      @channel = channel_owner.channel
+      @registered_listeners = Set.new
+      @listeners_mutex = Mutex.new
+      @logs = []
+      wait_for_event_info_before
+    end
+
+    private def wait_for_event_info_before
+      @channel.async_send_message_to_server(
+        "waitForEventInfo",
+        {
+          "info": {
+            "waitId": @wait_id,
+            "phase": "before",
+            "event": @event,
+          }
+        },
+      )
+    end
+
+    private def wait_for_event_info_after(error: nil)
+      @channel.async_send_message_to_server(
+        "waitForEventInfo",
+        {
+          "info": {
+            "waitId": @wait_id,
+            "phase": "after",
+            "error": error,
+          }.compact,
+        },
+      )
+    end
+
+    def reject_on_event(emitter, event, error_or_proc, predicate: nil)
+      listener = -> (*args) {
+        if !predicate || predicate.call(*args)
+          if error_or_proc.respond_to?(:call)
+            reject(error_or_proc.call)
+          else
+            reject(error_or_proc)
+          end
+        end
+      }
+      register_listener(emitter, event, listener)
+
+      self
+    end
+
+    def reject_on_timeout(timeout_ms, message)
+      return if timeout_ms <= 0
+
+      Concurrent::Promises.schedule(timeout_ms / 1000.0) do
+        reject(TimeoutError.new(message: message))
+      end.rescue do |err|
+        puts err, err.backtrace
+      end
+
+      self
+    end
+
+    private def cleanup
+      listeners = @listeners_mutex.synchronize do
+        @registered_listeners.to_a.tap { @registered_listeners.clear }
+      end
+      listeners.each do |emitter, event, listener|
+        emitter.off(event, listener)
+      end
+    end
+
+    def force_fulfill(result)
+      fulfill(result)
+    end
+
+    def force_reject(error)
+      reject(error)
+    end
+
+    private def fulfill(result)
+      cleanup
+      return if @result.resolved?
+      @result.fulfill(result)
+      wait_for_event_info_after
+    end
+
+    private def reject(error)
+      cleanup
+      return if @result.resolved?
+      klass = error.is_a?(TimeoutError) ? TimeoutError : Error
+      ex = klass.new(message: "#{error.message}#{format_log_recording(@logs)}")
+      @result.reject(ex)
+      wait_for_event_info_after(error: ex)
+    end
+
+    # @param [Playwright::EventEmitter]
+    # @param
+    def wait_for_event(emitter, event, predicate: nil)
+      listener = -> (*args) {
+        begin
+          if !predicate || predicate.call(*args)
+            fulfill(args.first)
+          end
+        rescue => err
+          reject(err)
+        end
+      }
+      register_listener(emitter, event, listener)
+
+      self
+    end
+
+    private def register_listener(emitter, event, listener)
+      emitter.on(event, listener)
+      remove_later = false
+      @listeners_mutex.synchronize do
+        if @result.resolved?
+          remove_later = true
+        else
+          @registered_listeners << [emitter, event, listener]
+        end
+      end
+      emitter.off(event, listener) if remove_later
+    end
+
+    attr_reader :result
+
+    def log(message)
+      @logs << message
+      begin
+        @channel.async_send_message_to_server(
+          "waitForEventInfo",
+          {
+            "info": {
+              "waitId": @wait_id,
+              "phase": "log",
+              "message": message,
+            },
+          },
+        )
+      rescue => err
+        # ignore
+      end
+    end
+
+    # @param logs [Array<String>]
+    private def format_log_recording(logs)
+      return "" if logs.empty?
+
+      header = " logs "
+      header_length = 60
+      left_length = ((header_length - header.length) / 2.0).to_i
+      right_length = header_length - header.length - left_length
+      new_line = "\n"
+      "#{new_line}#{'=' * left_length}#{header}#{'=' * right_length}#{new_line}#{logs.join(new_line)}#{new_line}#{'=' * header_length}"
+    end
+  end
+end