playwright-ruby-client 1.39.1 → 1.40.0

data/lib/playwright/api_response_impl.rb

@@ -1,6 +1,6 @@
 module Playwright
   define_api_implementation :APIResponseImpl do
-    include Utils::Errors::SafeCloseError
+    include Utils::Errors::TargetClosedErrorMethods
 
     # @params context [APIRequestContext]
     # @params initializer [Hash]
@@ -50,7 +50,7 @@ module Playwright
       raise AlreadyDisposedError.new unless binary
       Base64.strict_decode64(binary)
     rescue => err
-      if safe_close_error?(err)
+      if target_closed_error?(err)
         raise AlreadyDisposedError.new
       else
         raise

data/lib/playwright/channel_owners/api_request_context.rb

@@ -115,12 +115,12 @@ module Playwright
         case data
         when String
           if headers_obj&.any? { |key, value| key.downcase == 'content-type' && value == 'application/json' }
-            json_data = data
+            json_data = json_parsable?(data) ? data : data.to_json
           else
             post_data_buffer = data
           end
         when Hash, Array, Numeric, true, false
-          json_data = data
+          json_data = data.to_json
         else
           raise ArgumentError.new("Unsupported 'data' type: #{data.class}")
         end
@@ -142,7 +142,6 @@ module Playwright
       if post_data_buffer
         fetch_params[:postData] = Base64.strict_encode64(post_data_buffer)
       end
-
       fetch_params[:jsonData] = json_data
       fetch_params[:formData] = form_data
       fetch_params[:multipartData] = multipart_data
@@ -174,5 +173,15 @@ module Playwright
         { name: key, value: value.to_s }
       end
     end
+
+    private def json_parsable?(data)
+      return false unless data.is_a?(String)
+      begin
+        JSON.parse(data)
+        true
+      rescue JSON::ParserError
+        false
+      end
+    end
   end
 end

data/lib/playwright/channel_owners/browser.rb

@@ -3,17 +3,21 @@ require 'fileutils'
 module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_browser.py
   define_channel_owner :Browser do
-    include Utils::Errors::SafeCloseError
+    include Utils::Errors::TargetClosedErrorMethods
     include Utils::PrepareBrowserContextOptions
 
     private def after_initialize
       @browser_type = @parent
       @connected = true
-      @closed_or_closing = false
       @should_close_connection_on_close = false
 
       @contexts = Set.new
       @channel.on('close', method(:on_close))
+      @close_reason = nil
+    end
+
+    private def close_reason
+      @close_reason
     end
 
     def contexts
@@ -63,16 +67,16 @@ module Playwright
       @browser_type = browser_type
     end
 
-    def close
-      return if @closed_or_closing
-      @closed_or_closing = true
-      @channel.send_message_to_server('close')
+    def close(reason: nil)
+      @close_reason = reason
       if @should_close_connection_on_close
         @connection.stop
+      else
+        @channel.send_message_to_server('close', { reason: reason }.compact)
       end
       nil
     rescue => err
-      raise unless safe_close_error?(err)
+      raise unless target_closed_error?(err)
     end
 
     def version

data/lib/playwright/channel_owners/browser_context.rb

@@ -1,7 +1,6 @@
 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
@@ -68,6 +67,9 @@ module Playwright
           ChannelOwners::Page.from_nullable(params['page']),
         )
       })
+
+      @closed_promise = Concurrent::Promises.resolvable_future
+      @close_reason = nil
       set_event_to_subscription_mapping({
         Events::BrowserContext::Console => 'console',
         Events::BrowserContext::Dialog => 'dialog',
@@ -77,7 +79,7 @@ module Playwright
         Events::BrowserContext::RequestFailed => "requestFailed",
       })
 
-      @closed_promise = Concurrent::Promises.resolvable_future
+      @close_was_called = false
     end
 
     private def update_options(context_options:, browser_options:)
@@ -382,13 +384,17 @@ module Playwright
     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}\"")
-      wait_helper.wait_for_event(self, event, predicate: predicate)
+      waiter = Waiter.new(self, wait_name: "browser_context.expect_event(#{event})")
+      timeout_value = timeout || @timeout_settings.timeout
+      waiter.reject_on_timeout(timeout_value, "Timeout #{timeout}ms exceeded while waiting for event \"#{event}\"")
+      unless event == Events::BrowserContext::Close
+        waiter.reject_on_event(self, Events::BrowserContext::Close, TargetClosedError.new)
+      end
+      waiter.wait_for_event(self, event, predicate: predicate)
 
       block&.call
 
-      wait_helper.promise.value!
+      waiter.result.value!
     end
 
     private def on_close
@@ -397,7 +403,18 @@ module Playwright
       @closed_promise.fulfill(true)
     end
 
-    def close
+    def close(reason: nil)
+      return if @close_was_called
+      @close_was_called = true
+      @close_reason = reason
+
+      inner_close
+      @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.
@@ -413,11 +430,6 @@ module Playwright
 
         har.delete
       end
-      @channel.send_message_to_server('close')
-      @closed_promise.value!
-      nil
-    rescue => err
-      raise unless safe_close_error?(err)
     end
 
     # REMARK: enable_debug_console is playwright-ruby-client specific method.
@@ -459,6 +471,10 @@ module Playwright
       end
     end
 
+    private def effective_close_reason
+      @close_reason || @browser&.send(:close_reason)
+    end
+
     def expect_console_message(predicate: nil, timeout: nil, &block)
       params = {
         predicate: predicate,
@@ -502,10 +518,14 @@ module Playwright
     end
 
     # called from InputFiles
-    # @param name [string]
+    # @param filepath [string]
     # @return [WritableStream]
-    private def create_temp_file(name)
-      result = @channel.send_message_to_server('createTempFile', name: name)
+    private def create_temp_file(filepath)
+      result = @channel.send_message_to_server(
+        'createTempFile',
+        name: File.basename(filepath),
+        lastModifiedMs: File.mtime(filepath).to_i * 1000,
+      )
       ChannelOwners::WritableStream.from(result)
     end
   end

data/lib/playwright/channel_owners/frame.rb

@@ -71,12 +71,24 @@ module Playwright
       ChannelOwners::Response.from_nullable(resp)
     end
 
-    private def setup_navigation_wait_helper(timeout:)
-      WaitHelper.new.tap do |helper|
-        helper.reject_on_event(@page, Events::Page::Close, AlreadyClosedError.new)
-        helper.reject_on_event(@page, Events::Page::Crash, CrashedError.new)
-        helper.reject_on_event(@page, Events::Page::FrameDetached, FrameAlreadyDetachedError.new)
-        helper.reject_on_timeout(timeout, "Timeout #{timeout}ms exceeded.")
+    class CrashedError < StandardError
+      def initialize
+        super('Navigation failed because page crashed!')
+      end
+    end
+
+    class FrameAlreadyDetachedError < StandardError
+      def initialize
+        super('Navigating frame was detached!')
+      end
+    end
+
+    private def setup_navigation_waiter(wait_name:, timeout_value:)
+      Waiter.new(page, wait_name: "frame.#{wait_name}").tap do |waiter|
+        waiter.reject_on_event(@page, Events::Page::Close, -> { @page.send(:close_error_with_reason) })
+        waiter.reject_on_event(@page, Events::Page::Crash, CrashedError.new)
+        waiter.reject_on_event(@page, Events::Page::FrameDetached, FrameAlreadyDetachedError.new, predicate: -> (frame) { frame == self })
+        waiter.reject_on_timeout(timeout_value, "Timeout #{timeout_value}ms exceeded.")
       end
     end
 
@@ -85,21 +97,30 @@ module Playwright
       option_timeout = timeout || @page.send(:timeout_settings).navigation_timeout
       time_start = Time.now
 
-      wait_helper = setup_navigation_wait_helper(timeout: option_timeout)
+      waiter = setup_navigation_waiter(wait_name: :expect_navigation, timeout_value: option_timeout)
 
+      to_url = url ? " to \"#{url}\"" : ''
+      waiter.log("waiting for navigation#{to_url} until '#{option_wait_until}'")
       predicate =
         if url
           matcher = UrlMatcher.new(url, base_url: @page.context.send(:base_url))
-          ->(event) { event['error'] || matcher.match?(event['url']) }
+          ->(event) {
+            if event['error']
+              true
+            else
+              waiter.log("  navigated to \"#{event['url']}\"")
+              matcher.match?(event['url'])
+            end
+          }
         else
           ->(_) { true }
         end
 
-      wait_helper.wait_for_event(@event_emitter, 'navigated', predicate: predicate)
+      waiter.wait_for_event(@event_emitter, 'navigated', predicate: predicate)
 
       block&.call
 
-      event = wait_helper.promise.value!
+      event = waiter.result.value!
       if event['error']
         raise event['error']
       end
@@ -135,11 +156,14 @@ module Playwright
         return
       end
 
-      wait_helper = setup_navigation_wait_helper(timeout: option_timeout)
+      waiter = setup_navigation_waiter(wait_name: :wait_for_load_state, timeout_value: option_timeout)
 
-      predicate = ->(state) { state == option_state }
-      wait_helper.wait_for_event(@event_emitter, 'loadstate', predicate: predicate)
-      wait_helper.promise.value!
+      predicate = ->(actual_state) {
+        waiter.log("\"#{actual_state}\" event fired")
+        actual_state == option_state
+      }
+      waiter.wait_for_event(@event_emitter, 'loadstate', predicate: predicate)
+      waiter.result.value!
 
       nil
     end

data/lib/playwright/channel_owners/page.rb

@@ -4,7 +4,7 @@ require_relative '../locator_utils'
 module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_page.py
   define_channel_owner :Page do
-    include Utils::Errors::SafeCloseError
+    include Utils::Errors::TargetClosedErrorMethods
     include LocatorUtils
     attr_writer :owned_context
 
@@ -33,10 +33,12 @@ module Playwright
       @frames = Set.new
       @frames << @main_frame
       @opener = ChannelOwners::Page.from_nullable(@initializer['opener'])
+      @close_reason = nil
 
       @channel.on('bindingCall', ->(params) { on_binding(ChannelOwners::BindingCall.from(params['binding'])) })
+      @closed_or_crashed_promise = Concurrent::Promises.resolvable_future
       @channel.once('close', ->(_) { on_close })
-      @channel.on('crash', ->(_) { emit(Events::Page::Crash) })
+      @channel.on('crash', ->(_) { on_crash })
       @channel.on('download', method(:on_download))
       @channel.on('fileChooser', ->(params) {
         chooser = FileChooserImpl.new(
@@ -147,9 +149,19 @@ module Playwright
       @closed = true
       @browser_context.send(:remove_page, self)
       @browser_context.send(:remove_background_page, self)
+      if @closed_or_crashed_promise.pending?
+        @closed_or_crashed_promise.fulfill(close_error_with_reason)
+      end
       emit(Events::Page::Close)
     end
 
+    private def on_crash
+      if @closed_or_crashed_promise.pending?
+        @closed_or_crashed_promise.fulfill(TargetClosedError.new)
+      end
+      emit(Events::Page::Crash)
+    end
+
     private def on_download(params)
       artifact = ChannelOwners::Artifact.from(params['artifact'])
       download = DownloadImpl.new(
@@ -479,7 +491,8 @@ module Playwright
       @main_frame.title
     end
 
-    def close(runBeforeUnload: nil)
+    def close(runBeforeUnload: nil, reason: nil)
+      @close_reason = reason
       if @owned_context
         @owned_context.close
       else
@@ -488,7 +501,7 @@ module Playwright
       end
       nil
     rescue => err
-      raise if !safe_close_error?(err) || !runBeforeUnload
+      raise if !target_closed_error?(err) || !runBeforeUnload
     end
 
     def closed?
@@ -878,34 +891,34 @@ module Playwright
       end
     end
 
-    class AlreadyClosedError < StandardError
-      def initialize
-        super('Page closed')
-      end
-    end
-
     class FrameAlreadyDetachedError < StandardError
       def initialize
         super('Navigating frame was detached!')
       end
     end
 
+    private def close_error_with_reason
+      reason = @close_reason || @browser_context.send(:effective_close_reason)
+      TargetClosedError.new(message: reason)
+    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}\"")
+      waiter = Waiter.new(self, wait_name: "Page.expect_event(#{event})")
+      timeout_value = timeout || @timeout_settings.timeout
+      waiter.reject_on_timeout(timeout_value, "Timeout #{timeout_value}ms exceeded while waiting for event \"#{event}\"")
 
       unless event == Events::Page::Crash
-        wait_helper.reject_on_event(self, Events::Page::Crash, CrashedError.new)
+        waiter.reject_on_event(self, Events::Page::Crash, CrashedError.new)
       end
 
       unless event == Events::Page::Close
-        wait_helper.reject_on_event(self, Events::Page::Close, AlreadyClosedError.new)
+        waiter.reject_on_event(self, Events::Page::Close, -> { close_error_with_reason })
       end
 
-      wait_helper.wait_for_event(self, event, predicate: predicate)
+      waiter.wait_for_event(self, event, predicate: predicate)
       block&.call
 
-      wait_helper.promise.value!
+      waiter.result.value!
     end
 
     def expect_console_message(predicate: nil, timeout: nil, &block)

data/lib/playwright/channel_owners/web_socket.rb

@@ -33,29 +33,24 @@ module Playwright
       end
     end
 
-    class PageClosedError < StandardError
-      def initialize
-        super('Page closed')
-      end
-    end
-
     def expect_event(event, predicate: nil, timeout: nil, &block)
-      wait_helper = WaitHelper.new
-      wait_helper.reject_on_timeout(timeout || @parent.send(:timeout_settings).timeout, "Timeout while waiting for event \"#{event}\"")
+      waiter = Waiter.new(self, wait_name: "WebSocket.expect_event(#{event})")
+      timeout_value = timeout || @parent.send(:timeout_settings).timeout
+      waiter.reject_on_timeout(timeout_value, "Timeout #{timeout_value}ms exceeded while waiting for event \"#{event}\"")
 
       unless event == Events::WebSocket::Close
-        wait_helper.reject_on_event(self, Events::WebSocket::Close, SocketClosedError.new)
+        waiter.reject_on_event(self, Events::WebSocket::Close, SocketClosedError.new)
       end
 
       unless event == Events::WebSocket::Error
-        wait_helper.reject_on_event(self, Events::WebSocket::Error, SocketError.new)
+        waiter.reject_on_event(self, Events::WebSocket::Error, SocketError.new)
       end
 
-      wait_helper.reject_on_event(@parent, 'close', PageClosedError.new)
-      wait_helper.wait_for_event(self, event, predicate: predicate)
+      waiter.reject_on_event(@parent, 'close', -> { @parent.send(:close_error_with_reason) })
+      waiter.wait_for_event(self, event, predicate: predicate)
       block&.call
 
-      wait_helper.promise.value!
+      waiter.result.value!
     end
     alias_method :wait_for_event, :expect_event
 

data/lib/playwright/connection.rb

@@ -23,6 +23,7 @@ module Playwright
       @root_object = RootChannelOwner.new(self)
       @remote = false
       @tracing_count = 0
+      @closed_error = nil
     end
 
     attr_reader :local_utils
@@ -41,6 +42,15 @@ module Playwright
 
     def stop
       @transport.stop
+      cleanup
+    end
+
+    def cleanup(cause: nil)
+      @closed_error = cause || TargetClosedError.new
+      @callbacks.each_value do |callback|
+        callback.reject(@closed_error)
+      end
+      @callbacks.clear
     end
 
     def initialize_playwright
@@ -60,6 +70,8 @@ module Playwright
     end
 
     def async_send_message_to_server(guid, method, params, metadata: nil)
+      return if @closed_error
+
       callback = Concurrent::Promises.resolvable_future
 
       with_generated_id do |id|
@@ -130,6 +142,8 @@ module Playwright
     end
 
     def dispatch(msg)
+      return if @closed_error
+
       id = msg['id']
       if id
         callback = @callbacks.delete(id)
@@ -139,8 +153,10 @@ module Playwright
         end
 
         error = msg['error']
-        if error
-          callback.reject(::Playwright::Error.parse(error['error']))
+        if error && !msg['result']
+          parsed_error = ::Playwright::Error.parse(error['error'])
+          parsed_error.log = msg['log']
+          callback.reject(parsed_error)
         else
           result = replace_guids_with_channels(msg['result'])
           callback.fulfill(result)

data/lib/playwright/errors.rb

@@ -7,6 +7,11 @@ module Playwright
           message: error_payload['message'],
           stack: error_payload['stack'],
         )
+      elsif error_payload['name'] == 'TargetClosedError'
+        TargetClosedError.new(
+          message: error_payload['message'],
+          stack: error_payload['stack'],
+        )
       else
         new(
           name: error_payload['name'],
@@ -19,14 +24,20 @@ module Playwright
     # @param name [String]
     # @param message [String]
     # @param stack [Array<String>]
-    def initialize(name:, message:, stack:)
-      super("#{name}: #{message}")
+    def initialize(message:, name: nil, stack: nil)
+      super(message)
       @name = name
       @message = message
       @stack = stack
     end
 
     attr_reader :name, :message, :stack
+
+    def log=(log)
+      return unless log
+      format_call_log = log.join("\n  - ")
+      @message = "#{@message}\nCall log:\n#{format_call_log}\n"
+    end
   end
 
   class DriverCrashedError < StandardError
@@ -41,6 +52,13 @@ module Playwright
     end
   end
 
+  class TargetClosedError < Error
+    def initialize(message: nil, stack: [])
+      _message = message || 'Target page, context or browser has been closed'
+      super(name: 'TargetClosedError', message: _message, stack: stack)
+    end
+  end
+
   class WebError
     def initialize(error, page)
       @error = error

data/lib/playwright/input_files.rb

@@ -15,7 +15,7 @@ module Playwright
 
     def as_method_and_params
       if has_large_file?
-        ['setInputFilePaths', params_for_set_input_file_paths]
+        ['setInputFiles', params_for_set_input_file_paths]
       else
         ['setInputFiles', params_for_set_input_files]
       end
@@ -40,7 +40,7 @@ module Playwright
       writable_streams = @files.map do |file|
         case file
         when String
-          writable_stream = @context.send(:create_temp_file, File.basename(file))
+          writable_stream = @context.send(:create_temp_file, file)
 
           File.open(file, 'rb') do |file|
             writable_stream.write(file)
@@ -48,7 +48,7 @@ module Playwright
 
           writable_stream.channel
         when File
-          writable_stream = @context.send(:create_temp_file, File.basename(file.path))
+          writable_stream = @context.send(:create_temp_file, file.path)
           writable_stream.write(file)
 
           writable_stream.channel
@@ -78,7 +78,7 @@ module Playwright
         end
       end
 
-      { files: file_payloads }
+      { payloads: file_payloads }
     end
 
     private def raise_argument_error

data/lib/playwright/locator_assertions_impl.rb

@@ -79,7 +79,7 @@ module Playwright
       expected
     end
 
-    private def to_expected_text_values(items, match_substring = false, normalize_white_space = false, ignore_case = false)
+    private def to_expected_text_values(items, match_substring: false, normalize_white_space: false, ignore_case: false)
       return [] unless items.respond_to?(:each)
 
       items.each.with_object([]) do |item, out|
@@ -109,9 +109,9 @@ module Playwright
       if expected.respond_to?(:each)
         expected_text = to_expected_text_values(
           expected,
-          true,
-          true,
-          ignoreCase,
+          match_substring: true,
+          normalize_white_space: true,
+          ignore_case: ignoreCase,
         )
 
         expect_impl(
@@ -127,9 +127,9 @@ module Playwright
       else
         expected_text = to_expected_text_values(
           [expected],
-          true,
-          true,
-          ignoreCase
+          match_substring: true,
+          normalize_white_space: true,
+          ignore_case: ignoreCase,
         )
 
         expect_impl(
@@ -146,8 +146,8 @@ module Playwright
     end
     _define_negation :to_contain_text
 
-    def to_have_attribute(name, value, timeout: nil)
-      expected_text = to_expected_text_values([value])
+    def to_have_attribute(name, value, ignoreCase: nil, timeout: nil)
+      expected_text = to_expected_text_values([value], ignore_case: ignoreCase)
       expect_impl(
         "to.have.attribute.value",
         {
@@ -278,9 +278,9 @@ module Playwright
       if expected.respond_to?(:each)
         expected_text = to_expected_text_values(
           expected,
-          true,
-          true,
-          ignoreCase,
+          match_substring: true,
+          normalize_white_space: true,
+          ignore_case: ignoreCase,
         )
         expect_impl(
           "to.have.text.array",
@@ -295,9 +295,9 @@ module Playwright
       else
         expected_text = to_expected_text_values(
           [expected],
-          true,
-          true,
-          ignoreCase,
+          match_substring: true,
+          normalize_white_space: true,
+          ignore_case: ignoreCase,
         )
         expect_impl(
           "to.have.text",

data/lib/playwright/test.rb

@@ -60,9 +60,9 @@ module Playwright
         # to_be_visible => be_visible
         # not_to_be_visible => not_be_visible
         root_method_name = method_name.gsub("to_", "")
-        Matchers.define_method(root_method_name) do |*args, **kwargs| 
+        Matchers.send(:define_method, root_method_name) do |*args, **kwargs|
           Matchers::PlaywrightMatcher.new(method_name, *args, **kwargs)
         end
       end
   end
-end
+end