playwright-ruby-client 0.6.4 → 0.8.0

data/lib/playwright/channel_owners/response.rb

@@ -4,7 +4,7 @@ require 'json'
 module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_network.py
   define_channel_owner :Response do
-    def after_initialize
+    private def after_initialize
       @request = ChannelOwners::Request.from(@initializer['request'])
       timing = @initializer['timing']
       @request.send(:update_timings,
@@ -44,6 +44,14 @@ module Playwright
       end.to_h
     end
 
+    def server_addr
+      @channel.send_message_to_server('serverAddr')
+    end
+
+    def security_details
+      @channel.send_message_to_server('securityDetails')
+    end
+
     def finished
       @channel.send_message_to_server('finished')
     end

data/lib/playwright/channel_owners/web_socket.rb

@@ -0,0 +1,87 @@
+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
+
+    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}\"")
+
+      unless event == Events::WebSocket::Close
+        wait_helper.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)
+      end
+
+      wait_helper.reject_on_event(@parent, 'close', PageClosedError.new)
+      wait_helper.wait_for_event(self, event, predicate: predicate)
+      block&.call
+
+      wait_helper.promise.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/connection.rb

@@ -5,10 +5,8 @@ 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

data/lib/playwright/transport.rb

@@ -8,7 +8,6 @@ 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'

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '0.6.4'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.12.0'
+  VERSION = '0.8.0'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.13.0'
 end

data/lib/playwright/web_socket_client.rb

@@ -0,0 +1,164 @@
+require 'openssl'
+require 'socket'
+
+begin
+  require 'websocket/driver'
+rescue LoadError
+  raise "websocket-driver is required. Add `gem 'websocket-driver'` to your Gemfile"
+end
+
+# ref: https://github.com/rails/rails/blob/master/actioncable/lib/action_cable/connection/client_socket.rb
+# ref: https://github.com/cavalle/chrome_remote/blob/master/lib/chrome_remote/web_socket_client.rb
+module Playwright
+  class WebSocketClient
+    class SecureSocketFactory
+      def initialize(host, port)
+        @host = host
+        @port = port || 443
+      end
+
+      def create
+        tcp_socket = TCPSocket.new(@host, @port)
+        OpenSSL::SSL::SSLSocket.new(tcp_socket).tap(&:connect)
+      end
+    end
+
+    class DriverImpl # providing #url, #write(string)
+      def initialize(url)
+        @url = url
+
+        endpoint = URI.parse(url)
+        @socket =
+          if endpoint.scheme == 'wss'
+            SecureSocketFactory.new(endpoint.host, endpoint.port).create
+          else
+            TCPSocket.new(endpoint.host, endpoint.port)
+          end
+      end
+
+      attr_reader :url
+
+      def write(data)
+        @socket.write(data)
+      rescue Errno::EPIPE
+        raise EOFError.new('already closed')
+      rescue Errno::ECONNRESET
+        raise EOFError.new('closed by remote')
+      end
+
+      def readpartial(maxlen = 1024)
+        @socket.readpartial(maxlen)
+      rescue Errno::ECONNRESET
+        raise EOFError.new('closed by remote')
+      end
+
+      def disconnect
+        @socket.close
+      end
+    end
+
+    STATE_CONNECTING = 0
+    STATE_OPENED = 1
+    STATE_CLOSING = 2
+    STATE_CLOSED = 3
+
+    def initialize(url:, max_payload_size:)
+      @impl = DriverImpl.new(url)
+      @driver = ::WebSocket::Driver.client(@impl, max_length: max_payload_size)
+
+      setup
+    end
+
+    class TransportError < StandardError; end
+
+    private def setup
+      @ready_state = STATE_CONNECTING
+      @driver.on(:open) do
+        @ready_state = STATE_OPENED
+        handle_on_open
+      end
+      @driver.on(:close) do |event|
+        @ready_state = STATE_CLOSED
+        handle_on_close(reason: event.reason, code: event.code)
+      end
+      @driver.on(:error) do |event|
+        if !handle_on_error(error_message: event.message)
+          raise TransportError.new(event.message)
+        end
+      end
+      @driver.on(:message) do |event|
+        handle_on_message(event.data)
+      end
+    end
+
+    private def wait_for_data
+      @driver.parse(@impl.readpartial)
+    end
+
+    def start
+      @driver.start
+
+      Thread.new do
+        wait_for_data until @ready_state >= STATE_CLOSING
+      rescue EOFError
+        # Google Chrome was gone.
+        # We have nothing todo. Just finish polling.
+        if @ready_state < STATE_CLOSING
+          handle_on_close(reason: 'Going Away', code: 1001)
+        end
+      end
+    end
+
+    # @param message [String]
+    def send_text(message)
+      return if @ready_state >= STATE_CLOSING
+      @driver.text(message)
+    end
+
+    def close(code: 1000, reason: "")
+      return if @ready_state >= STATE_CLOSING
+      @ready_state = STATE_CLOSING
+      @driver.close(reason, code)
+    end
+
+    def on_open(&block)
+      @on_open = block
+    end
+
+    # @param block [Proc(reason: String, code: Numeric)]
+    def on_close(&block)
+      @on_close = block
+    end
+
+    # @param block [Proc(error_message: String)]
+    def on_error(&block)
+      @on_error = block
+    end
+
+    def on_message(&block)
+      @on_message = block
+    end
+
+    private def handle_on_open
+      @on_open&.call
+    end
+
+    private def handle_on_close(reason:, code:)
+      @on_close&.call(reason, code)
+      @impl.disconnect
+    end
+
+    private def handle_on_error(error_message:)
+      return false if @on_error.nil?
+
+      @on_error.call(error_message)
+      true
+    end
+
+    private def handle_on_message(data)
+      return if @ready_state != STATE_OPENED
+
+      @on_message&.call(data)
+    end
+  end
+end

data/lib/playwright/web_socket_transport.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Playwright
+  # ref: https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_transport.py
+  class WebSocketTransport
+    # @param ws_endpoint [String] EndpointURL of WebSocket
+    def initialize(ws_endpoint:)
+      @ws_endpoint = ws_endpoint
+      @debug = ENV['DEBUG'].to_s == 'true' || ENV['DEBUG'].to_s == '1'
+    end
+
+    def on_message_received(&block)
+      @on_message = 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)
+
+      @ws.send_text(msg)
+    rescue Errno::EPIPE, IOError
+      raise AlreadyDisconnectedError.new('send_message failed')
+    end
+
+    # Terminate playwright-cli driver.
+    def stop
+      return unless @ws
+
+      future = Concurrent::Promises.resolvable_future
+
+      @ws.on_close do
+        future.fulfill(nil)
+      end
+
+      begin
+        @ws.close
+      rescue EOFError => err
+        # ignore EOLError. The connection is already closed.
+        future.fulfill(err)
+      end
+
+      # Wait for closed actually.
+      future.value!
+    end
+
+    # Start `playwright-cli run-driver`
+    #
+    # @note This method blocks until playwright-cli exited. Consider using Thread or Future.
+    def async_run
+      ws = WebSocketClient.new(
+        url: @ws_endpoint,
+        max_payload_size: 256 * 1024 * 1024, # 256MB
+      )
+      promise = Concurrent::Promises.resolvable_future
+      ws.on_open do
+        promise.fulfill(ws)
+      end
+      ws.on_error do |error_message|
+        promise.reject(WebSocketClient::TransportError.new(error_message))
+      end
+
+      # Some messages can be sent just after start, before setting @ws.on_message
+      # So set this handler before ws.start.
+      ws.on_message do |data|
+        handle_on_message(data)
+      end
+
+      ws.start
+      @ws = promise.value!
+      @ws.on_error do |error|
+        puts "[WebSocketTransport] error: #{error}"
+        @on_driver_crashed&.call
+      end
+    rescue Errno::ECONNREFUSED => err
+      raise WebSocketClient::TransportError.new(err)
+    end
+
+    private
+
+    def handle_on_message(data)
+      obj = JSON.parse(data)
+
+      debug_recv_message(obj) if @debug
+      @on_message&.call(obj)
+    end
+
+    def debug_send_message(message)
+      puts "\x1b[33mSEND>\x1b[0m#{message}"
+    end
+
+    def debug_recv_message(message)
+      puts "\x1b[33mRECV>\x1b[0m#{message}"
+    end
+  end
+end

data/lib/playwright_api/android.rb

@@ -25,20 +25,20 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     private def event_emitter_proxy

data/lib/playwright_api/android_device.rb

@@ -161,14 +161,20 @@ module Playwright
       raise NotImplementedError.new('web_views is not implemented yet.')
     end
 
+    # @nodoc
+    def tap_on(selector, duration: nil, timeout: nil)
+      wrap_impl(@impl.tap_on(unwrap_impl(selector), duration: unwrap_impl(duration), timeout: unwrap_impl(timeout)))
+    end
+
     # @nodoc
     def tree
       wrap_impl(@impl.tree)
     end
 
+    # -- inherited from EventEmitter --
     # @nodoc
-    def tap_on(selector, duration: nil, timeout: nil)
-      wrap_impl(@impl.tap_on(unwrap_impl(selector), duration: unwrap_impl(duration), timeout: unwrap_impl(timeout)))
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
@@ -183,12 +189,6 @@ module Playwright
       event_emitter_proxy.on(event, callback)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
-    end
-
     private def event_emitter_proxy
       @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end