playwright-ruby-client 0.0.8 → 1.58.1.alpha1

data/lib/playwright/channel_owners/playwright.rb

@@ -1,15 +1,21 @@
 module Playwright
   define_channel_owner :Playwright do
     def chromium
-      @chromium ||= ::Playwright::ChannelOwners::BrowserType.from(@initializer['chromium'])
+      @chromium ||= ::Playwright::ChannelOwners::BrowserType.from(@initializer['chromium']).tap do |browser_type|
+        browser_type.send(:update_playwright, self)
+      end
     end
 
     def firefox
-      @firefox ||= ::Playwright::ChannelOwners::BrowserType.from(@initializer['firefox'])
+      @firefox ||= ::Playwright::ChannelOwners::BrowserType.from(@initializer['firefox']).tap do |browser_type|
+        browser_type.send(:update_playwright, self)
+      end
     end
 
     def webkit
-      @webkit ||= ::Playwright::ChannelOwners::BrowserType.from(@initializer['webkit'])
+      @webkit ||= ::Playwright::ChannelOwners::BrowserType.from(@initializer['webkit']).tap do |browser_type|
+        browser_type.send(:update_playwright, self)
+      end
     end
 
     def android
@@ -20,38 +26,27 @@ 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 selectors
+      @selectors ||= ::Playwright::SelectorsImpl.new
+    end
 
-      def mobile?
-        @is_mobile
-      end
+    def devices
+      @connection.local_utils.devices
+    end
 
-      def has_touch?
-        @has_touch
+    # used only from Playwright#connect_to_browser_server
+    private def pre_launched_browser
+      unless @initializer['preLaunchedBrowser']
+        raise 'Malformed endpoint. Did you use launchServer method?'
       end
+      ::Playwright::ChannelOwners::Browser.from(@initializer['preLaunchedBrowser'])
     end
 
-    def devices
-      @devices ||= @initializer['deviceDescriptors'].map do |item|
-        [item['name'], DeviceDescriptor.new(item['descriptor'])]
-      end.to_h
+    private def pre_connected_android_device
+      unless @initializer['preConnectedAndroidDevice']
+        raise 'Malformed endpoint. Did you use Android.launchServer method?'
+      end
+      ::Playwright::ChannelOwners::AndroidDevice.from(@initializer['preConnectedAndroidDevice'])
     end
   end
 end

data/lib/playwright/channel_owners/request.rb

@@ -3,9 +3,10 @@ require 'base64'
 module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_network.py
   define_channel_owner :Request do
-    def after_initialize
+    private def after_initialize
       @redirected_from = ChannelOwners::Request.from_nullable(@initializer['redirectedFrom'])
       @redirected_from&.send(:update_redirected_to, self)
+      @provisional_headers = RawHeaders.new(@initializer['headers'])
       @timing = {
         startTime: 0,
         domainLookupStart: -1,
@@ -17,11 +18,29 @@ module Playwright
         responseStart: -1,
         responseEnd: -1,
       }
-      @headers = parse_headers(@initializer['headers'])
+      @fallback_overrides = {}
+      @url = @initializer['url']
+    end
+
+    private def fallback_overrides
+      @fallback_overrides
+    end
+
+    def apply_fallback_overrides(overrides)
+      allowed_key = %i[url method headers postData]
+      overrides.each do |key, value|
+        raise ArgumentError.new("invalid key: #{key}") unless allowed_key.include?(key)
+        @fallback_overrides[key] = value
+      end
+      @fallback_overrides
     end
 
     def url
-      @initializer['url']
+      @fallback_overrides[:url] || @url
+    end
+
+    private def internal_url
+      @url
     end
 
     def resource_type
@@ -29,7 +48,7 @@ module Playwright
     end
 
     def method
-      @initialize['method']
+      @fallback_overrides[:method] || @initializer['method']
     end
 
     def post_data
@@ -40,10 +59,10 @@ module Playwright
       data = post_data
       return unless data
 
-      content_type = @headers['content-type']
+      content_type = headers['content-type']
       return unless content_type
 
-      if content_type == "application/x-www-form-urlencoded"
+      if content_type.include?("application/x-www-form-urlencoded")
         URI.decode_www_form(data).to_h
       else
         JSON.parse(data)
@@ -51,25 +70,40 @@ module Playwright
     end
 
     def post_data_buffer
-      base64_content = @initializer['postData']
-      if base64_content
+      if (override = @fallback_overrides[:postData])
+        return override
+      end
+
+      if (base64_content = @initializer['postData'])
         Base64.strict_decode64(base64_content)
       else
         nil
       end
     end
 
-    def headers
-      @headers
-    end
-
     def response
       resp = @channel.send_message_to_server('response')
       ChannelOwners::Response.from_nullable(resp)
     end
 
+    class FramePageNotReadyError < StandardError
+      MESSAGE = [
+        'Frame for this navigation request is not available, because the request',
+        'was issued before the frame is created. You can check whether the request',
+        'is a navigation request by calling isNavigationRequest() method.',
+      ].join('\n').freeze
+
+      def initialize
+        super(MESSAGE)
+      end
+    end
+
     def frame
-      @initializer['frame']
+      ChannelOwners::Frame.from(@initializer['frame']).tap do |result|
+        unless result.page
+          raise FramePageNotReadyError.new
+        end
+      end
     end
 
     def navigation_request?
@@ -80,16 +114,84 @@ module Playwright
       @failure_text
     end
 
-    attr_reader :headers, :redirected_from, :redirected_to, :timing
+    attr_reader :redirected_from, :redirected_to, :timing
+
+    def headers
+      if (override = @fallback_overrides[:headers])
+        RawHeaders.new(HttpHeaders.new(override).as_serialized).headers
+      else
+        @provisional_headers.headers
+      end
+    end
+
+    # @return [RawHeaders|nil]
+    private def actual_headers
+      if (override = @fallback_overrides[:headers])
+        RawHeaders.new(HttpHeaders.new(override).as_serialized)
+      else
+        @actual_headers ||= raw_request_headers
+      end
+    end
+
+    private def raw_request_headers
+      RawHeaders.new(@channel.send_message_to_server('rawRequestHeaders'))
+    end
+
+    def all_headers
+      actual_headers.headers
+    end
+
+    def headers_array
+      actual_headers.headers_array
+    end
+
+    def header_value(name)
+      actual_headers.get(name)
+    end
+
+    def header_values(name)
+      actual_headers.get_all(name)
+    end
+
+    def sizes
+      res = response
+      unless res
+        raise 'Unable to fetch sizes for failed request'
+      end
+
+      res.send(:sizes)
+    end
 
     private def update_redirected_to(request)
       @redirected_to = request
     end
 
-    private def parse_headers(headers)
-      headers.map do |header|
-        [header['name'].downcase, header['value']]
-      end.to_h
+    private def update_failure_text(failure_text)
+      @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_response_end_timing(response_end_timing)
+      @timing[:responseEnd] = response_end_timing
     end
   end
 end

data/lib/playwright/channel_owners/response.rb

@@ -1,5 +1,118 @@
+require 'base64'
+require 'json'
+
 module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_network.py
   define_channel_owner :Response do
+    private def after_initialize
+      @provisional_headers = RawHeaders.new(@initializer['headers'])
+      @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"],
+      )
+      @finished_promise = Concurrent::Promises.resolvable_future
+    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
+      @provisional_headers.headers
+    end
+
+    # @return [RawHeaders]
+    private def actual_headers
+      @actual_headers ||= raw_response_headers
+    end
+
+    private def raw_response_headers
+      RawHeaders.new(@channel.send_message_to_server('rawResponseHeaders'))
+    end
+
+    def from_service_worker
+      @initializer['fromServiceWorker']
+    end
+
+    alias_method :from_service_worker?, :from_service_worker
+
+    def all_headers
+      actual_headers.headers
+    end
+
+    def headers_array
+      actual_headers.headers_array
+    end
+
+    def header_value(name)
+      actual_headers.get(name)
+    end
+
+    def header_values(name)
+      actual_headers.get_all(name)
+    end
+
+    def server_addr
+      @channel.send_message_to_server('serverAddr')
+    end
+
+    def security_details
+      @channel.send_message_to_server('securityDetails')
+    end
+
+    def finished
+      @finished_promise.value!
+    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
+
+    private def sizes
+      resp = @channel.send_message_to_server('sizes')
+
+      {
+        requestBodySize: resp['requestBodySize'],
+        requestHeadersSize: resp['requestHeadersSize'],
+        responseBodySize: resp['responseBodySize'],
+        responseHeadersSize: resp['responseHeadersSize'],
+      }
+    end
+
+    private def mark_as_finished
+      @finished_promise.fulfill(nil)
+    end
   end
 end

data/lib/playwright/channel_owners/route.rb

@@ -0,0 +1,181 @@
+require 'base64'
+require 'mime/types'
+
+module Playwright
+  define_channel_owner :Route do
+    private def set_handling_future(future)
+      @handling_future = future
+    end
+
+    private def handling_with_result(done, &block)
+      chain = @handling_future
+      raise 'Route is already handled!' unless chain
+      block.call
+      @handling_future = nil
+      chain.fulfill(done)
+    end
+
+    def request
+      ChannelOwners::Request.from(@initializer['request'])
+    end
+
+    def abort(errorCode: nil)
+      handling_with_result(true) do
+        params = { requestUrl: request.send(:internal_url), errorCode: errorCode }.compact
+        # TODO _race_with_page_close
+        @channel.async_send_message_to_server('abort', params)
+      end
+    end
+
+    def fulfill(
+          body: nil,
+          contentType: nil,
+          headers: nil,
+          json: nil,
+          path: nil,
+          status: nil,
+          response: nil)
+      handling_with_result(true) do
+        option_status = status
+        option_headers = headers
+        option_body = body
+
+        if json
+          raise ArgumentError.new('Can specify either body or json parameters') if body
+          option_body = JSON.generate(json)
+        end
+
+        params = {}
+
+        if response
+          option_status ||= response.status
+          option_headers ||= response.headers
+
+          if !body && !path && response.is_a?(APIResponseImpl)
+            if response.send(:_request).send(:same_connection?, self)
+              params[:fetchResponseUid] = response.send(:fetch_uid)
+            else
+              option_body = response.body
+            end
+          end
+        end
+
+        content =
+          if option_body
+            option_body
+          elsif path
+            File.read(path)
+          else
+            nil
+          end
+
+        param_headers = option_headers || {}
+        if contentType
+          param_headers['content-type'] = contentType
+        elsif json
+          param_headers['content-type'] = 'application/json'
+        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[:status] = option_status || 200
+        params[:headers] = HttpHeaders.new(param_headers).as_serialized
+        params[:requestUrl] = request.send(:internal_url)
+
+        @channel.async_send_message_to_server('fulfill', params)
+      end
+    end
+
+    def fallback(headers: nil, method: nil, postData: nil, url: nil)
+      overrides = {
+        headers: headers,
+        method: method,
+        postData: postData,
+        url: url,
+      }.compact
+
+      handling_with_result(false) do
+        request.apply_fallback_overrides(overrides)
+      end
+    end
+
+    def fetch(headers: nil, method: nil, postData: nil, url: nil, maxRedirects: nil, maxRetries: nil, timeout: nil)
+      api_request_context = @context.request
+      api_request_context.send(:_inner_fetch,
+        request,
+        url,
+        headers: headers,
+        method: method,
+        data: postData,
+        maxRedirects: maxRedirects,
+        maxRetries: maxRetries,
+        timeout: timeout,
+      )
+    end
+
+    def continue(headers: nil, method: nil, postData: nil, url: nil)
+      overrides = {
+        headers: headers,
+        method: method,
+        postData: postData,
+        url: url,
+      }.compact
+
+      handling_with_result(true) do
+        request.apply_fallback_overrides(overrides)
+        async_continue_route
+      end
+    end
+
+    private def async_continue_route(internal: false)
+      post_data_for_wire =
+        if (post_data_from_overrides = request.send(:fallback_overrides)[:postData])
+          post_data_for_wire = Base64.strict_encode64(post_data_from_overrides)
+        else
+          nil
+        end
+
+      params = request.send(:fallback_overrides).dup
+
+      if params[:headers]
+        params[:headers] = HttpHeaders.new(params[:headers]).as_serialized
+      end
+
+      if post_data_for_wire
+        params[:postData] = post_data_for_wire
+      end
+      params[:requestUrl] = request.send(:internal_url)
+      params[:isFallback] = internal
+
+      # TODO _race_with_page_close
+      @channel.async_send_message_to_server('continue', params)
+    end
+
+    def redirect_navigation_request(url)
+      handling_with_result(true) do
+        # TODO _race_with_page_close
+        @channel.send_message_to_server('redirectNavigationRequest', { url: url })
+      end
+    end
+
+    private def mime_type_for(filepath)
+      mime_types = MIME::Types.type_for(filepath)
+      mime_types.first.to_s || 'application/octet-stream'
+    end
+
+    private def update_context(context)
+      @context = context
+    end
+  end
+end

data/lib/playwright/channel_owners/stream.rb

@@ -0,0 +1,30 @@
+require 'base64'
+
+module Playwright
+  define_channel_owner :Stream do
+    def save_as(path)
+      File.open(path, 'wb') do |f|
+        read_with_block do |chunk|
+          f.write(chunk)
+        end
+      end
+    end
+
+    def read_all(&block)
+      out = StringIO.new
+      read_with_block do |chunk|
+        out.write(chunk)
+      end
+      out.string
+    end
+
+    private def read_with_block(&block)
+      loop do
+        binary = @channel.send_message_to_server('read', size: 1024 * 1024)
+        break if !binary || binary.length == 0
+        decoded_chunk = Base64.strict_decode64(binary)
+        block.call(decoded_chunk)
+      end
+    end
+  end
+end