playwright-ruby-client 0.0.8 → 1.58.1.alpha1

data/lib/playwright/channel_owners/tracing.rb

@@ -0,0 +1,117 @@
+module Playwright
+  define_channel_owner :Tracing do
+    def start(name: nil, title: nil, screenshots: nil, snapshots: nil, sources: nil)
+      params = {
+        name: name,
+        screenshots: screenshots,
+        snapshots: snapshots,
+        sources: sources,
+      }.compact
+      @include_sources = params[:sources] || false
+      @channel.send_message_to_server('tracingStart', params)
+      trace_name = @channel.send_message_to_server('tracingStartChunk', { title: title, name: name }.compact)
+      start_collecting_stacks(trace_name)
+    end
+
+    def start_chunk(title: nil, name: nil)
+      trace_name = @channel.send_message_to_server('tracingStartChunk', { title: title, name: name }.compact)
+      start_collecting_stacks(trace_name)
+    end
+
+    private def start_collecting_stacks(trace_name)
+      unless @is_tracing
+        @is_tracing = true
+        @connection.set_in_tracing(true)
+      end
+      local_utils = @connection.local_utils
+      @stacks_id = local_utils&.tracing_started(@traces_dir, trace_name)
+    end
+
+    def stop_chunk(path: nil)
+      do_stop_chunk(file_path: path)
+    end
+
+    def stop(path: nil)
+      do_stop_chunk(file_path: path)
+      @channel.send_message_to_server('tracingStop')
+    end
+
+    private def do_stop_chunk(file_path:)
+      if @is_tracing
+        @is_tracing = false
+        @connection.set_in_tracing(false)
+      end
+      local_utils = @connection.local_utils
+
+      unless file_path
+        # Not interested in any artifacts
+        @channel.send_message_to_server('tracingStopChunk', mode: 'discard')
+        if @stacks_id
+          local_utils.trace_discarded(@stacks_id) if local_utils
+        end
+
+        return
+      end
+
+      is_local = !@connection.remote?
+      if is_local
+        unless local_utils
+          raise 'Cannot save trace because localUtils is unavailable.'
+        end
+
+        result = @channel.send_message_to_server_result('tracingStopChunk', mode: 'entries')
+        local_utils.zip(
+          zipFile: file_path,
+          entries: result['entries'],
+          stacksId: @stacks_id,
+          mode: 'write',
+          includeSources: @include_sources,
+        )
+
+        return
+      end
+
+
+      result = @channel.send_message_to_server_result('tracingStopChunk', mode: 'archive')
+      # The artifact may be missing if the browser closed while stopping tracing.
+      unless result['artifact']
+        if @stacks_id
+          local_utils.trace_discarded(@stacks_id) if local_utils
+        end
+
+        return
+      end
+
+      # Save trace to the final local file.
+      artifact = ChannelOwners::Artifact.from(result['artifact'])
+      artifact.save_as(file_path)
+      artifact.delete
+
+      return unless local_utils
+
+      local_utils.zip(
+        zipFile: file_path,
+        entries: [],
+        stacksId: @stacks_id,
+        mode: 'append',
+        includeSources: @include_sources,
+      )
+    end
+
+    private def update_traces_dir(traces_dir)
+      @traces_dir = traces_dir
+    end
+
+    def group(name, location: nil)
+      params = {
+        name: name,
+        location: location,
+      }.compact
+      @channel.send_message_to_server('tracingGroup', params)
+    end
+
+    def group_end
+      @channel.send_message_to_server('tracingGroupEnd')
+    end
+  end
+end

data/lib/playwright/channel_owners/web_socket.rb

@@ -0,0 +1,96 @@
+require 'base64'
+
+module Playwright
+  define_channel_owner :WebSocket do
+    private def after_initialize
+      @closed = false
+
+      @channel.on('frameSent', -> (params) {
+        on_frame_sent(params['opcode'], params['data'])
+      })
+      @channel.on('frameReceived', -> (params) {
+        on_frame_received(params['opcode'], params['data'])
+      })
+      @channel.on('socketError', -> (params) {
+        emit(Events::WebSocket::Error, params['error'])
+      })
+      @channel.on('close', -> (_) { on_close })
+    end
+
+    def url
+      @initializer['url']
+    end
+
+    class SocketClosedError < StandardError
+      def initialize
+        super('Socket closed')
+      end
+    end
+
+    class SocketError < StandardError
+      def initialize
+        super('Socket error')
+      end
+    end
+
+    def expect_event(event, predicate: nil, timeout: nil, &block)
+      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
+        waiter.reject_on_event(self, Events::WebSocket::Close, SocketClosedError.new)
+      end
+
+      unless event == Events::WebSocket::Error
+        waiter.reject_on_event(self, Events::WebSocket::Error, SocketError.new)
+      end
+
+      waiter.reject_on_event(@parent, 'close', -> { @parent.send(:close_error_with_reason) })
+      waiter.wait_for_event(self, event, predicate: predicate)
+      if @closed
+        if event == Events::WebSocket::Close
+          waiter.force_fulfill(nil)
+        else
+          waiter.force_reject(SocketClosedError.new)
+        end
+      end
+      block&.call
+      if @closed
+        if event == Events::WebSocket::Close
+          waiter.force_fulfill(nil)
+        else
+          waiter.force_reject(SocketClosedError.new)
+        end
+      end
+
+      waiter.result.value!
+    end
+    alias_method :wait_for_event, :expect_event
+
+    private def on_frame_sent(opcode, data)
+      if opcode == 2
+        emit(Events::WebSocket::FrameSent, Base64.strict_decode64(data))
+      else
+        emit(Events::WebSocket::FrameSent, data)
+      end
+    end
+
+    private def on_frame_received(opcode, data)
+      if opcode == 2
+        emit(Events::WebSocket::FrameReceived, Base64.strict_decode64(data))
+      else
+        emit(Events::WebSocket::FrameReceived, data)
+      end
+    end
+
+    def closed?
+      @closed
+    end
+
+    private def on_close
+      @closed = true
+      emit(Events::WebSocket::Close)
+    end
+  end
+end

data/lib/playwright/channel_owners/worker.rb

@@ -0,0 +1,46 @@
+module Playwright
+  define_channel_owner :Worker do
+    attr_writer :context, :page
+
+    private def after_initialize
+      @channel.once('close', ->(_) { on_close })
+
+      set_event_to_subscription_mapping({
+        Events::Worker::Console => "console",
+      })
+    end
+
+    private def on_close
+      @page&.send(:remove_worker, self)
+      @context&.send(:remove_service_worker, self)
+      emit(Events::Worker::Close, self)
+    end
+
+    def url
+      @initializer['url']
+    end
+
+    def evaluate(expression, arg: nil)
+      JavaScript::Expression.new(expression, arg).evaluate(@channel)
+    end
+
+    def evaluate_handle(expression, arg: nil)
+      JavaScript::Expression.new(expression, arg).evaluate_handle(@channel)
+    end
+
+    def expect_event(event, predicate: nil, timeout: nil, &block)
+      waiter = Waiter.new(self, wait_name: "Worker.expect_event(#{event})")
+      timeout_value = timeout || @page&.send(:_timeout_settings)&.timeout || @context&.send(:_timeout_settings)&.timeout
+      waiter.reject_on_timeout(timeout_value, "Timeout #{timeout_value}ms exceeded while waiting for event \"#{event}\"")
+
+      unless event == Events::Worker::Close
+        waiter.reject_on_event(self, Events::Worker::Close, TargetClosedError.new)
+      end
+
+      waiter.wait_for_event(self, event, predicate: predicate)
+      block&.call
+
+      waiter.result.value!
+    end
+  end
+end

data/lib/playwright/channel_owners/writable_stream.rb

@@ -0,0 +1,14 @@
+require 'base64'
+
+module Playwright
+  define_channel_owner :WritableStream do
+    # @param readable [File|IO]
+    def write(readable, bufsize = 1048576)
+      while buf = readable.read(bufsize)
+        binary = Base64.strict_encode64(buf)
+        @channel.send_message_to_server('write', binary: binary)
+      end
+      @channel.send_message_to_server('close')
+    end
+  end
+end

data/lib/playwright/clock_impl.rb

@@ -0,0 +1,67 @@
+module Playwright
+  define_api_implementation :ClockImpl do
+    def initialize(browser_context)
+      @browser_context = browser_context
+    end
+
+    def install(time: nil)
+      if time
+        @browser_context.send(:clock_install, parse_time(time))
+      else
+        @browser_context.send(:clock_install, {})
+      end
+    end
+
+    def fast_forward(ticks)
+      @browser_context.send(:clock_fast_forward, parse_ticks(ticks))
+    end
+
+    def pause_at(time)
+      @browser_context.send(:clock_pause_at, parse_time(time))
+    end
+
+    def resume
+      @browser_context.send(:clock_resume)
+    end
+
+    def run_for(ticks)
+      @browser_context.send(:clock_run_for, parse_ticks(ticks))
+    end
+
+    def set_fixed_time(time)
+      @browser_context.send(:clock_set_fixed_time, parse_time(time))
+    end
+
+    def set_system_time(time)
+      @browser_context.send(:clock_set_system_time, parse_time(time))
+    end
+
+    private def parse_time(time)
+      case time
+      when Integer
+        { timeNumber: time }
+      when String
+        { timeString: time }
+      when DateTime
+        { timeNumber: time.to_time.to_i * 1000 }
+      else
+        if time.respond_to?(:utc)
+          { timeNumber: time.utc.to_i * 1000 }
+        else
+          raise ArgumentError.new('time must be either integer, string or a Time object')
+        end
+      end
+    end
+
+    private def parse_ticks(ticks)
+      case ticks
+      when Integer
+        { ticksNumber: ticks }
+      when String
+        { ticksString: ticks }
+      else
+        raise ArgumentError.new('ticks must be either integer or string')
+      end
+    end
+  end
+end

data/lib/playwright/connection.rb

@@ -5,70 +5,124 @@ module Playwright
   # https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_connection.py
   # https://github.com/microsoft/playwright-java/blob/master/playwright/src/main/java/com/microsoft/playwright/impl/Connection.java
   class Connection
-    def initialize(playwright_cli_executable_path:)
-      @transport = Transport.new(
-        playwright_cli_executable_path: playwright_cli_executable_path
-      )
+    def initialize(transport)
+      @transport = transport
       @transport.on_message_received do |message|
         dispatch(message)
       end
+      @transport.on_driver_crashed do
+        callbacks = @callbacks_mutex.synchronize { @callbacks.values }
+        callbacks.each { |callback| callback.reject(::Playwright::DriverCrashedError.new) }
+        raise ::Playwright::DriverCrashedError.new
+      end
+      @transport.on_driver_closed do
+        cleanup
+      end
 
       @objects = {} # Hash[ guid => ChannelOwner ]
+      @objects_mutex = Mutex.new
       @waiting_for_object = {} # Hash[ guid => Promise<ChannelOwner> ]
       @callbacks = {} # Hash [ guid => Promise<ChannelOwner> ]
+      @callbacks_mutex = Mutex.new
       @root_object = RootChannelOwner.new(self)
+      @remote = false
+      @tracing_count = 0
+      @closed_error = nil
+    end
+
+    attr_reader :local_utils
+
+    def mark_as_remote
+      @remote = true
     end
 
-    def run
-      @transport.run
+    def remote?
+      @remote
+    end
+
+    def async_run
+      @transport.async_run
     end
 
     def stop
       @transport.stop
+      cleanup
     end
 
-    def async_wait_for_object_with_known_name(guid)
-      if @objects[guid]
-        return @objects[guid]
+    def cleanup(cause: nil)
+      @closed_error = TargetClosedError.new(message: cause)
+      callbacks = @callbacks_mutex.synchronize do
+        @callbacks.values.tap { @callbacks.clear }
       end
+      callbacks.each { |callback| callback.reject(@closed_error) }
+    end
 
-      callback = Concurrent::Promises.resolvable_future
-      @waiting_for_object[guid] = callback
-      callback
+    def initialize_playwright
+      # Avoid Error: sdkLanguage: expected one of (javascript|python|java|csharp)
+      # ref: https://github.com/microsoft/playwright/pull/18308
+      # ref: https://github.com/YusukeIwaki/playwright-ruby-client/issues/228
+      result = send_message_to_server('', 'initialize', { sdkLanguage: 'python' })
+      ChannelOwners::Playwright.from(result['playwright'])
     end
 
-    def wait_for_object_with_known_name(guid)
-      async_wait_for_object_with_known_name.value!
+    def set_in_tracing(value)
+      if value
+        @tracing_count += 1
+      else
+        @tracing_count -= 1
+      end
     end
 
-    def async_send_message_to_server(guid, method, params)
+    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|
         # register callback promise object first.
         # @see https://github.com/YusukeIwaki/puppeteer-ruby/pull/34
-        @callbacks[id] = callback
+        @callbacks_mutex.synchronize { @callbacks[id] = callback }
+
+        _metadata = {}
+        frames = []
+        if metadata
+          frames = metadata[:stack]
+          _metadata[:wallTime] = metadata[:wallTime]
+          _metadata[:apiName] = metadata[:apiName]
+          _metadata[:location] = metadata[:stack].first
+          _metadata[:internal] = !metadata[:apiName]
+          if metadata[:title]
+            _metadata[:title] = metadata[:title]
+          end
+        end
+        _metadata.compact!
 
         message = {
           id: id,
           guid: guid,
           method: method,
           params: replace_channels_with_guids(params),
+          metadata: _metadata,
         }
+
         begin
           @transport.send_message(message)
         rescue => err
-          @callbacks.delete(id)
+          @callbacks_mutex.synchronize { @callbacks.delete(id) }
           callback.reject(err)
           raise unless err.is_a?(Transport::AlreadyDisconnectedError)
         end
+
+        if @tracing_count > 0 && !frames.empty? && guid != 'localUtils' && !remote?
+          @local_utils.add_stack_to_tracing_no_reply(id, frames)
+        end
       end
 
       callback
     end
 
-    def send_message_to_server(guid, method, params)
-      async_send_message_to_server(guid, method, params).value!
+    def send_message_to_server(guid, method, params, metadata: nil)
+      async_send_message_to_server(guid, method, params, metadata: metadata).value!
     end
 
     private
@@ -79,35 +133,42 @@ module Playwright
     # end
     # ````
     def with_generated_id(&block)
-      @last_id ||= 0
-      block.call(@last_id += 1)
+      id = @callbacks_mutex.synchronize do
+        @last_id ||= 0
+        @last_id += 1
+      end
+      block.call(id)
     end
 
     # @param guid [String]
     # @param parent [Playwright::ChannelOwner]
     # @note This method should be used internally. Accessed via .send method from Playwright::ChannelOwner, so keep private!
     def update_object_from_channel_owner(guid, parent)
-      @objects[guid] = parent
+      @objects_mutex.synchronize { @objects[guid] = parent }
     end
 
     # @param guid [String]
     # @note This method should be used internally. Accessed via .send method from Playwright::ChannelOwner, so keep private!
     def delete_object_from_channel_owner(guid)
-      @objects.delete(guid)
+      @objects_mutex.synchronize { @objects.delete(guid) }
     end
 
     def dispatch(msg)
+      return if @closed_error
+
       id = msg['id']
       if id
-        callback = @callbacks.delete(id)
+        callback = @callbacks_mutex.synchronize { @callbacks.delete(id) }
 
         unless callback
           raise "Cannot find command to respond: #{id}"
         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)
@@ -121,28 +182,37 @@ 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
 
-      if method == "__dispose__"
-        object = @objects[guid]
-        unless object
-          raise "Cannot find object to dispose: #{guid}"
+      object = @objects_mutex.synchronize { @objects[guid] }
+      unless object
+        raise "Cannot find object to \"#{method}\": #{guid}"
+      end
+
+      if method == "__adopt__"
+        child = @objects_mutex.synchronize { @objects[params["guid"]] }
+        unless child
+          raise "Unknown new child: #{params['guid']}"
         end
-        object.send(:dispose!)
+        object.send(:adopt!, child)
         return
       end
 
-      object = @objects[guid]
-      unless object
-        raise "Cannot find object to emit \"#{method}\": #{guid}"
+      if method == "__dispose__"
+        object.send(:dispose!, reason: params["reason"])
+        return
       end
+
       object.channel.emit(method, replace_guids_with_channels(params))
     end
 
@@ -177,8 +247,9 @@ module Playwright
 
       if payload.is_a?(Hash)
         guid = payload['guid']
-        if guid && @objects[guid]
-          return @objects[guid].channel
+        if guid
+          object = @objects_mutex.synchronize { @objects[guid] }
+          return object.channel if object
         end
 
         return payload.map { |k, v| [k, replace_guids_with_channels(v)] }.to_h
@@ -189,38 +260,15 @@ module Playwright
 
     # @return [Playwright::ChannelOwner|nil]
     def create_remote_object(parent_guid:, type:, guid:, initializer:)
-      parent = @objects[parent_guid]
+      parent = @objects_mutex.synchronize { @objects[parent_guid] }
       unless parent
         raise "Cannot find parent object #{parent_guid} to create #{guid}"
       end
       initializer = replace_guids_with_channels(initializer)
 
-      class_name = case type
-      when 'Browser'
-        case initializer['name']
-        when 'chromium'
-          'ChromiumBrowser'
-        when 'webkit'
-          'WebKitBrowser'
-        when 'firefox'
-          'FirefoxBrowser'
-        else
-          'Browser'
-        end
-      when 'BrowserContext'
-        browser_name = initializer['browserName']
-        if browser_name == 'chromium'
-          'ChromiumBrowserContext'
-        else
-          'BrowserContext'
-        end
-      else
-        type
-      end
-
       result =
         begin
-          ChannelOwners.const_get(class_name).new(
+          ChannelOwners.const_get(type).new(
             parent,
             type,
             guid,
@@ -230,7 +278,7 @@ module Playwright
           raise "Missing type #{type}"
         end
 
-      callback = @waiting_for_object.delete(guid)
+      callback = @objects_mutex.synchronize { @waiting_for_object.delete(guid) }
       callback&.fulfill(result)
 
       result

data/lib/playwright/console_message_impl.rb

@@ -0,0 +1,29 @@
+module Playwright
+  define_api_implementation :ConsoleMessageImpl do
+    def initialize(event, page, worker)
+      @event = event
+      @page = page
+      @worker = worker
+    end
+
+    attr_reader :page, :worker
+
+    def type
+      @event['type']
+    end
+
+    def text
+      @event['text']
+    end
+
+    def args
+      @event['args']&.map do |arg|
+        ChannelOwner.from(arg)
+      end
+    end
+
+    def location
+      @event['location']
+    end
+  end
+end