playwright-ruby-client 0.2.0 → 0.5.2

data/lib/playwright/channel_owners/playwright.rb

@@ -20,38 +20,35 @@ module Playwright
       @electron ||= ::Playwright::ChannelOwners::Electron.from(@initializer['electron'])
     end
 
-    class DeviceDescriptor
-      class Viewport
-        def initialize(hash)
-          @width = hash['width']
-          @heirhgt = hash['height']
-        end
-        attr_reader :width, :height
-      end
-
-      def initialize(hash)
-        @user_agent = hash["userAgent"]
-        @viewport = Viewport.new(hash["viewport"])
-        @device_scale_factor = hash["deviceScaleFactor"]
-        @is_mobile = hash["isMobile"]
-        @has_touch = hash["hasTouch"]
-      end
-
-      attr_reader :user_agent, :viewport, :device_scale_factor
-
-      def mobile?
-        @is_mobile
-      end
-
-      def has_touch?
-        @has_touch
-      end
+    def selectors
+      @selectors ||= ::Playwright::ChannelOwners::Selectors.from(@initializer['selectors'])
     end
 
     def devices
       @devices ||= @initializer['deviceDescriptors'].map do |item|
-        [item['name'], DeviceDescriptor.new(item['descriptor'])]
+        [item['name'], parse_device_descriptor(item['descriptor'])]
       end.to_h
     end
+
+    private def parse_device_descriptor(descriptor)
+      # This return value can be passed into Browser#new_context as it is.
+      # ex:
+      # ```
+      #   iPhone = playwright.devices['iPhone 6']
+      #   context = browser.new_context(**iPhone)
+      #   page = context.new_page
+      #
+      # ```
+      {
+        userAgent: descriptor['userAgent'],
+        viewport: {
+          width: descriptor['viewport']['width'],
+          height: descriptor['viewport']['height'],
+        },
+        deviceScaleFactor: descriptor['deviceScaleFactor'],
+        isMobile: descriptor['isMobile'],
+        hasTouch: descriptor['hasTouch'],
+      }
+    end
   end
 end

data/lib/playwright/channel_owners/request.rb

@@ -29,7 +29,7 @@ module Playwright
     end
 
     def method
-      @initialize['method']
+      @initializer['method']
     end
 
     def post_data
@@ -69,7 +69,7 @@ module Playwright
     end
 
     def frame
-      @initializer['frame']
+      ChannelOwners::Frame.from(@initializer['frame'])
     end
 
     def navigation_request?
@@ -90,6 +90,30 @@ module Playwright
       @failure_text = failure_text
     end
 
+    private def update_timings(
+                  start_time:,
+                  domain_lookup_start:,
+                  domain_lookup_end:,
+                  connect_start:,
+                  secure_connection_start:,
+                  connect_end:,
+                  request_start:,
+                  response_start:)
+
+      @timing["startTime"] = start_time
+      @timing["domainLookupStart"] = domain_lookup_start
+      @timing["domainLookupEnd"] = domain_lookup_end
+      @timing["connectStart"] = connect_start
+      @timing["secureConnectionStart"] = secure_connection_start
+      @timing["connectEnd"] = connect_end
+      @timing["requestStart"] = request_start
+      @timing["responseStart"] = response_start
+    end
+
+    private def update_headers(headers)
+      @headers = parse_headers(headers)
+    end
+
     private def update_response_end_timing(response_end_timing)
       @timing[:responseEnd] = response_end_timing
     end

data/lib/playwright/channel_owners/response.rb

@@ -1,5 +1,65 @@
+require 'base64'
+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
+      @request = ChannelOwners::Request.from(@initializer['request'])
+      timing = @initializer['timing']
+      @request.send(:update_timings,
+        start_time: timing["startTime"],
+        domain_lookup_start: timing["domainLookupStart"],
+        domain_lookup_end: timing["domainLookupEnd"],
+        connect_start: timing["connectStart"],
+        secure_connection_start: timing["secureConnectionStart"],
+        connect_end: timing["connectEnd"],
+        request_start: timing["requestStart"],
+        response_start: timing["responseStart"],
+      )
+      @request.send(:update_headers, @initializer['requestHeaders'])
+    end
+    attr_reader :request
+
+    def url
+      @initializer['url']
+    end
+
+    def ok
+      status == 0 || (200...300).include?(status)
+    end
+    alias_method :ok?, :ok
+
+    def status
+      @initializer['status']
+    end
+
+    def status_text
+      @initializer['statusText']
+    end
+
+    def headers
+      @initializer['headers'].map do |header|
+        [header['name'].downcase, header['value']]
+      end.to_h
+    end
+
+    def finished
+      @channel.send_message_to_server('finished')
+    end
+
+    def body
+      binary = @channel.send_message_to_server("body")
+      Base64.strict_decode64(binary)
+    end
+    alias_method :text, :body
+
+    def json
+      JSON.parse(text)
+    end
+
+    def frame
+      @request.frame
+    end
   end
 end

data/lib/playwright/channel_owners/route.rb

@@ -0,0 +1,78 @@
+require 'base64'
+require 'mime/types'
+
+module Playwright
+  define_channel_owner :Route do
+    def request
+      ChannelOwners::Request.from(@initializer['request'])
+    end
+
+    def abort(errorCode: nil)
+      params = { errorCode: errorCode }.compact
+      @channel.async_send_message_to_server('abort', params)
+    end
+
+    def fulfill(
+          body: nil,
+          contentType: nil,
+          headers: nil,
+          path: nil,
+          status: nil)
+      params = {
+        contentType: contentType,
+        status: status,
+      }.compact
+
+      length = 0
+      content =
+        if body
+          body
+        elsif path
+          File.read(path)
+        else
+          nil
+        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
+        end
+        param_headers['content-length'] ||= content.length.to_s
+      end
+
+      params[:headers] = HttpHeaders.new(param_headers).as_serialized
+
+      @channel.async_send_message_to_server('fulfill', params)
+    end
+
+    def continue(headers: nil, method: nil, postData: nil, url: nil)
+      overrides = { url: url, method: method }.compact
+
+      if headers
+        overrides[:headers] = HttpHeaders.new(headers).as_serialized
+      end
+
+      if postData
+        overrides[:postData] = Base64.strict_encode64(postData)
+      end
+
+      @channel.async_send_message_to_server('continue', overrides)
+    end
+
+    private def mime_type_for(filepath)
+      mime_types = MIME::Types.type_for(filepath)
+      mime_types.first.to_s || 'application/octet-stream'
+    end
+  end
+end

data/lib/playwright/channel_owners/selectors.rb

@@ -1,4 +1,22 @@
 module Playwright
   # https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_selectors.py
-  define_channel_owner :Selectors
+  define_channel_owner :Selectors do
+    def register(name, contentScript: nil, path: nil, script: nil)
+      source =
+        if path
+          File.read(path)
+        elsif script
+          script
+        else
+          raise ArgumentError.new('Either path or script parameter must be specified')
+        end
+      params = { name: name, source: source }
+      if contentScript
+        params[:contentScript] = true
+      end
+      @channel.send_message_to_server('register', params)
+
+      nil
+    end
+  end
 end

data/lib/playwright/channel_owners/stream.rb

@@ -0,0 +1,15 @@
+require 'base64'
+
+module Playwright
+  define_channel_owner :Stream do
+    def save_as(path)
+      File.open(path, 'wb') do |f|
+        loop do
+          binary = @channel.send_message_to_server('read')
+          break if !binary || binary.length == 0
+          f.write(Base64.strict_decode64(binary))
+        end
+      end
+    end
+  end
+end

data/lib/playwright/connection.rb

@@ -12,6 +12,12 @@ module Playwright
       @transport.on_message_received do |message|
         dispatch(message)
       end
+      @transport.on_driver_crashed do
+        @callbacks.each_value do |callback|
+          callback.reject(::Playwright::DriverCrashedError.new)
+        end
+        raise ::Playwright::DriverCrashedError.new
+      end
 
       @objects = {} # Hash[ guid => ChannelOwner ]
       @waiting_for_object = {} # Hash[ guid => Promise<ChannelOwner> ]
@@ -19,26 +25,22 @@ module Playwright
       @root_object = RootChannelOwner.new(self)
     end
 
-    def run
-      @transport.run
+    def async_run
+      @transport.async_run
     end
 
     def stop
       @transport.stop
     end
 
-    def async_wait_for_object_with_known_name(guid)
+    def wait_for_object_with_known_name(guid)
       if @objects[guid]
         return @objects[guid]
       end
 
       callback = Concurrent::Promises.resolvable_future
       @waiting_for_object[guid] = callback
-      callback
-    end
-
-    def wait_for_object_with_known_name(guid)
-      async_wait_for_object_with_known_name.value!
+      callback.value!
     end
 
     def async_send_message_to_server(guid, method, params)
@@ -195,32 +197,9 @@ module Playwright
       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,

data/lib/playwright/download.rb

@@ -0,0 +1,27 @@
+module Playwright
+  class Download
+    def initialize(url:, suggested_filename:, artifact:)
+      @url = url
+      @suggested_filename = suggested_filename
+      @artifact = artifact
+    end
+
+    attr_reader :url, :suggested_filename
+
+    def delete
+      @artifact.delete
+    end
+
+    def failure
+      @artifact.failure
+    end
+
+    def path
+      @artifact.path_after_finished
+    end
+
+    def save_as(path)
+      @artifact.save_as(path)
+    end
+  end
+end

data/lib/playwright/errors.rb

@@ -27,6 +27,12 @@ module Playwright
     end
   end
 
+  class DriverCrashedError < StandardError
+    def initialize
+      super("[BUG] Playwright driver is crashed!")
+    end
+  end
+
   class TimeoutError < Error
     def initialize(message:, stack: [])
       super(name: 'TimeoutError', message: message, stack: stack)

data/lib/playwright/events.rb

@@ -24,8 +24,10 @@ end
   },
 
   BrowserContext: {
+    BackgroundPage: 'backgroundpage',
     Close: 'close',
     Page: 'page',
+    ServiceWorker: 'serviceworker',
   },
 
   BrowserServer: {
@@ -67,11 +69,6 @@ end
     Close: 'close',
   },
 
-  ChromiumBrowserContext: {
-    BackgroundPage: 'backgroundpage',
-    ServiceWorker: 'serviceworker',
-  },
-
   ElectronApplication: {
     Close: 'close',
     Window: 'window',

data/lib/playwright/keyboard_impl.rb

@@ -10,7 +10,7 @@ module Playwright
     end
 
     def up(key)
-      @channel.send_message_to_server('keyboardDown', key: key)
+      @channel.send_message_to_server('keyboardUp', key: key)
     end
 
     def insert_text(text)