playwright-ruby-client 1.16.0 → 1.17.1

data/lib/playwright/api_response_impl.rb

@@ -0,0 +1,73 @@
+module Playwright
+  define_api_implementation :APIResponseImpl do
+    include Utils::Errors::SafeCloseError
+
+    # @params context [APIRequestContext]
+    # @params initializer [Hash]
+  	def initialize(context, initializer)
+      @request = context
+      @initializer = initializer
+      @headers = RawHeaders.new(initializer['headers'])
+    end
+
+    def to_s
+      "#<APIResponse url=#{url} status=#{status} status_text=#{status_text}>"
+    end
+
+    def url
+      @initializer['url']
+    end
+
+    def ok
+      (200...300).include?(status)
+    end
+    alias_method :ok?, :ok
+
+    def status
+      @initializer['status']
+    end
+
+    def status_text
+      @initializer['statusText']
+    end
+
+    def headers
+      @headers.headers
+    end
+
+    def headers_array
+      @headers.headers_array
+    end
+
+    class AlreadyDisposedError < StandardError
+      def initialize
+        super('Response has been disposed')
+      end
+    end
+
+    def body
+      binary = @request.channel.send_message_to_server("fetchResponseBody", fetchUid: fetch_uid)
+      raise AlreadyDisposedError.new unless binary
+      Base64.strict_decode64(binary)
+    rescue => err
+      if safe_close_error?(err)
+        raise AlreadyDisposedError.new
+      else
+        raise
+      end
+    end
+    alias_method :text, :body
+
+    def json
+      JSON.parse(text)
+    end
+
+    def dispose
+      @request.channel.send_message_to_server("disposeAPIResponse", fetchUid: fetch_uid)
+    end
+
+    private def fetch_uid
+      @initializer['fetchUid']
+    end
+  end
+end

data/lib/playwright/channel.rb

@@ -71,7 +71,7 @@ module Playwright
       {
         apiName: api_name,
         stack: stacks.map do |loc|
-          { file: loc.absolute_path, line: loc.lineno, function: loc.label }
+          { file: loc.absolute_path || '', line: loc.lineno, function: loc.label }
         end,
       }
     end

data/lib/playwright/channel_owners/api_request_context.rb

@@ -1,4 +1,236 @@
+require 'base64'
+
 module Playwright
   define_channel_owner :APIRequestContext do
+    def dispose
+      @channel.send_message_to_server('dispose')
+    end
+
+    def delete(
+          url,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+      fetch(
+        url,
+        method: 'DELETE',
+        data: data,
+        failOnStatusCode: failOnStatusCode,
+        form: form,
+        headers: headers,
+        ignoreHTTPSErrors: ignoreHTTPSErrors,
+        multipart: multipart,
+        params: params,
+        timeout: timeout,
+      )
+    end
+
+    def head(
+          url,
+          failOnStatusCode: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          params: nil,
+          timeout: nil)
+      fetch(
+        url,
+        method: 'HEAD',
+        failOnStatusCode: failOnStatusCode,
+        headers: headers,
+        ignoreHTTPSErrors: ignoreHTTPSErrors,
+        params: params,
+        timeout: timeout,
+      )
+    end
+
+    def get(
+          url,
+          failOnStatusCode: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          params: nil,
+          timeout: nil)
+      fetch(
+        url,
+        method: 'GET',
+        failOnStatusCode: failOnStatusCode,
+        headers: headers,
+        ignoreHTTPSErrors: ignoreHTTPSErrors,
+        params: params,
+        timeout: timeout,
+      )
+    end
+
+    def patch(
+          url,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+      fetch(
+        url,
+        method: 'PATCH',
+        data: data,
+        failOnStatusCode: failOnStatusCode,
+        form: form,
+        headers: headers,
+        ignoreHTTPSErrors: ignoreHTTPSErrors,
+        multipart: multipart,
+        params: params,
+        timeout: timeout,
+      )
+    end
+
+    def put(
+          url,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+      fetch(
+        url,
+        method: 'PUT',
+        data: data,
+        failOnStatusCode: failOnStatusCode,
+        form: form,
+        headers: headers,
+        ignoreHTTPSErrors: ignoreHTTPSErrors,
+        multipart: multipart,
+        params: params,
+        timeout: timeout,
+      )
+    end
+
+    def post(
+          url,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+      fetch(
+        url,
+        method: 'POST',
+        data: data,
+        failOnStatusCode: failOnStatusCode,
+        form: form,
+        headers: headers,
+        ignoreHTTPSErrors: ignoreHTTPSErrors,
+        multipart: multipart,
+        params: params,
+        timeout: timeout,
+      )
+    end
+
+    def fetch(
+          urlOrRequest,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          method: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+
+      if [ChannelOwners::Request, String].none? { |type| urlOrRequest.is_a?(type) }
+        raise ArgumentError.new("First argument must be either URL string or Request")
+      end
+      if [data, form, multipart].compact.count > 1
+        raise ArgumentError.new("Only one of 'data', 'form' or 'multipart' can be specified")
+      end
+
+      request = urlOrRequest.is_a?(ChannelOwners::Request) ? urlOrRequest : nil
+      headers_obj = headers || request&.headers
+      fetch_params = {
+        url: request&.url || urlOrRequest,
+        params: object_to_array(params),
+        method: method || request&.method || 'GET',
+        headers: headers_obj ? HttpHeaders.new(headers_obj).as_serialized : nil,
+      }
+
+      json_data = nil
+      form_data = nil
+      multipart_data = nil
+      post_data_buffer = nil
+      if data
+        case data
+        when String
+          if headers_obj&.any? { |key, value| key.downcase == 'content-type' && value == 'application/json' }
+            json_data = data
+          else
+            post_data_buffer = data
+          end
+        when Hash, Array, Numeric, true, false
+          json_data = data
+        else
+          raise ArgumentError.new("Unsupported 'data' type: #{data.class}")
+        end
+      elsif form
+        form_data = object_to_array(form)
+      elsif multipart
+        multipart_data = multipart.map do |name, value|
+          if file_payload?(value)
+            { name: name, file: file_payload_to_json(value) }
+          else
+            { name: name, value: value.to_s }
+          end
+        end
+      end
+
+      if !json_data && !form_data && !multipart_data
+        post_data_buffer ||= request&.post_data_buffer
+      end
+      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
+      fetch_params[:timeout] = timeout
+      fetch_params[:failOnStatusCode] = failOnStatusCode
+      fetch_params[:ignoreHTTPSErrors] = ignoreHTTPSErrors
+      fetch_params.compact!
+      response = @channel.send_message_to_server('fetch', fetch_params)
+
+      APIResponseImpl.new(self, response)
+    end
+
+    private def file_payload?(value)
+      value.is_a?(Hash) &&
+        %w(name mimeType buffer).all? { |key| value.has_key?(key) || value.has_key?(key.to_sym) }
+    end
+
+    private def file_payload_to_json(payload)
+      {
+        name: payload[:name] || payload['name'],
+        mimeType: payload[:mimeType] || payload['mimeType'],
+        buffer: Base64.strict_encode64(payload[:buffer] || payload['buffer'])
+      }
+    end
+
+    private def object_to_array(hash)
+      hash&.map do |key, value|
+        { name: key, value: value.to_s }
+      end
+    end
   end
 end

data/lib/playwright/channel_owners/artifact.rb

@@ -1,14 +1,13 @@
 module Playwright
   define_channel_owner :Artifact do
     private def after_initialize
-      @remote = false
       @absolute_path = @initializer['absolutePath']
     end
 
     attr_reader :absolute_path
 
     def path_after_finished
-      if @remote
+      if @connection.remote?
         raise "Path is not available when using browser_type.connect(). Use save_as() to save a local copy."
       end
       @channel.send_message_to_server('pathAfterFinished')
@@ -30,9 +29,5 @@ module Playwright
     def cancel
       @channel.send_message_to_server('cancel')
     end
-
-    private def update_as_remote
-      @remote = true
-    end
   end
 end

data/lib/playwright/channel_owners/browser.rb

@@ -7,7 +7,7 @@ module Playwright
     private def after_initialize
       @connected = true
       @closed_or_closing = false
-      @remote = false
+      @should_close_connection_on_close = false
 
       @contexts = Set.new
       @channel.on('close', method(:on_close))
@@ -58,6 +58,9 @@ module Playwright
       return if @closed_or_closing
       @closed_or_closing = true
       @channel.send_message_to_server('close')
+      if @should_close_connection_on_close
+        @connection.stop
+      end
       nil
     rescue => err
       raise unless safe_close_error?(err)
@@ -99,13 +102,8 @@ module Playwright
       @contexts << context
     end
 
-    # called from BrowserType#connectOverCDP
-    private def update_as_remote
-      @remote = true
-    end
-
-    private def remote?
-      @remote
+    private def should_close_connection_on_close!
+      @should_close_connection_on_close = true
     end
 
     # called from BrowserContext#on_close with send(:remove_context), so keep private.

data/lib/playwright/channel_owners/browser_context.rb

@@ -4,7 +4,7 @@ module Playwright
     include Utils::Errors::SafeCloseError
     attr_accessor :browser
     attr_writer :owner_page, :options
-    attr_reader :tracing
+    attr_reader :tracing, :request
 
     private def after_initialize
       @pages = Set.new
@@ -15,6 +15,8 @@ module Playwright
       @background_pages = Set.new
 
       @tracing = TracingImpl.new(@channel, self)
+      @request = ChannelOwners::APIRequestContext.from(@initializer['APIRequestContext'])
+
       @channel.on('bindingCall', ->(params) { on_binding(ChannelOwners::BindingCall.from(params['binding'])) })
       @channel.once('close', ->(_) { on_close })
       @channel.on('page', ->(params) { on_page(ChannelOwners::Page.from(params['page']) )})
@@ -276,9 +278,6 @@ module Playwright
     def close
       if @options && @options.key?(:recordHar)
         har = ChannelOwners::Artifact.from(@channel.send_message_to_server('harExport'))
-        if @browser.send(:remote?)
-          har.update_as_remote
-        end
         har.save_as(@options[:recordHar][:path])
         har.delete
       end

data/lib/playwright/channel_owners/browser_type.rb

@@ -54,7 +54,6 @@ module Playwright
 
       result = @channel.send_message_to_server_result('connectOverCDP', params)
       browser = ChannelOwners::Browser.from(result['browser'])
-      browser.send(:update_as_remote)
 
       if result['defaultContext']
         context = ChannelOwners::BrowserContext.from(result['defaultContext'])

data/lib/playwright/channel_owners/fetch_request.rb

@@ -1,3 +1,5 @@
+require_relative './api_request_context'
+
 module Playwright
   module ChannelOwners
     class FetchRequest < APIRequestContext

data/lib/playwright/channel_owners/frame.rb

@@ -110,8 +110,8 @@ module Playwright
     def wait_for_load_state(state: nil, timeout: nil)
       option_state = state || 'load'
       option_timeout = timeout || @page.send(:timeout_settings).navigation_timeout
-      unless %w(load domcontentloaded networkidle).include?(option_state)
-        raise ArgumentError.new('state: expected one of (load|domcontentloaded|networkidle)')
+      unless %w(load domcontentloaded networkidle commit).include?(option_state)
+        raise ArgumentError.new('state: expected one of (load|domcontentloaded|networkidle|commit)')
       end
       if @load_states.include?(option_state)
         return
@@ -191,10 +191,6 @@ module Playwright
       @channel.send_message_to_server('isVisible', params)
     end
 
-    def locator(selector)
-      LocatorImpl.new(frame: self, timeout_settings: @page.send(:timeout_settings), selector: selector)
-    end
-
     def dispatch_event(selector, type, eventInit: nil, strict: nil, timeout: nil)
       params = {
         selector: selector,
@@ -404,6 +400,14 @@ module Playwright
       nil
     end
 
+    def locator(selector)
+      LocatorImpl.new(frame: self, timeout_settings: @page.send(:timeout_settings), selector: selector)
+    end
+
+    def frame_locator(selector)
+      FrameLocatorImpl.new(frame: self, timeout_settings: @page.send(:timeout_settings), frame_selector: selector)
+    end
+
     def focus(selector, strict: nil, timeout: nil)
       params = { selector: selector, strict: strict, timeout: timeout }.compact
       @channel.send_message_to_server('focus', params)

data/lib/playwright/channel_owners/page.rb

@@ -138,9 +138,6 @@ module Playwright
 
     private def on_download(params)
       artifact = ChannelOwners::Artifact.from(params['artifact'])
-      if @browser_context.browser.send(:remote?)
-        artifact.update_as_remote
-      end
       download = DownloadImpl.new(
         page: self,
         url: params['url'],
@@ -152,9 +149,6 @@ module Playwright
 
     private def on_video(params)
       artifact = ChannelOwners::Artifact.from(params['artifact'])
-      if @browser_context.browser.send(:remote?)
-        artifact.update_as_remote
-      end
       video.send(:set_artifact, artifact)
     end
 
@@ -261,10 +255,6 @@ module Playwright
       @main_frame.visible?(selector, strict: strict, timeout: timeout)
     end
 
-    def locator(selector)
-      @main_frame.locator(selector)
-    end
-
     def dispatch_event(selector, type, eventInit: nil, strict: nil, timeout: nil)
       @main_frame.dispatch_event(selector, type, eventInit: eventInit, strict: strict, timeout: timeout)
     end
@@ -568,6 +558,14 @@ module Playwright
         timeout: timeout)
     end
 
+    def locator(selector)
+      @main_frame.locator(selector)
+    end
+
+    def frame_locator(selector)
+      @main_frame.frame_locator(selector)
+    end
+
     def focus(selector, strict: nil, timeout: nil)
       @main_frame.focus(selector, strict: strict, timeout: timeout)
     end
@@ -735,6 +733,10 @@ module Playwright
       @workers.to_a
     end
 
+    def request
+      @browser_context.request
+    end
+
     def pause
       @browser_context.send(:pause)
     end
@@ -925,6 +927,11 @@ module Playwright
       @workers.delete(worker)
     end
 
+    # called from Video
+    private def remote_connection?
+      @connection.remote?
+    end
+
     # Expose guid for library developers.
     # Not intended to be used by users.
     def guid

data/lib/playwright/connection.rb

@@ -21,6 +21,15 @@ module Playwright
       @waiting_for_object = {} # Hash[ guid => Promise<ChannelOwner> ]
       @callbacks = {} # Hash [ guid => Promise<ChannelOwner> ]
       @root_object = RootChannelOwner.new(self)
+      @remote = false
+    end
+
+    def mark_as_remote
+      @remote = true
+    end
+
+    def remote?
+      @remote
     end
 
     def async_run

data/lib/playwright/frame_locator_impl.rb

@@ -0,0 +1,49 @@
+module Playwright
+  define_api_implementation :FrameLocatorImpl do
+    def initialize(frame:, timeout_settings:, frame_selector:)
+      @frame = frame
+      @timeout_settings = timeout_settings
+      @frame_selector = frame_selector
+    end
+
+    def locator(selector)
+      LocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        selector: "#{@frame_selector} >> control=enter-frame >> #{selector}",
+      )
+    end
+
+    def frame_locator(selector)
+      FrameLocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        frame_selector: "#{@frame_selector} >> control=enter-frame >> #{selector}",
+      )
+    end
+
+    def first
+      FrameLocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        frame_selector: "#{@frame_selector} >> nth=0",
+      )
+    end
+
+    def last
+      FrameLocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        frame_selector: "#{@frame_selector} >> nth=-1",
+      )
+    end
+
+    def nth(index)
+      FrameLocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        frame_selector: "#{@frame_selector} >> nth=#{index}",
+      )
+    end
+  end
+end

data/lib/playwright/locator_impl.rb

@@ -11,17 +11,17 @@ module Playwright
     end
 
     private def with_element(timeout: nil, &block)
+      timeout_or_default = @timeout_settings.timeout(timeout)
       start_time = Time.now
 
-      handle = @frame.wait_for_selector(@selector, strict: true, state: 'attached', timeout: timeout)
+      handle = @frame.wait_for_selector(@selector, strict: true, state: 'attached', timeout: timeout_or_default)
       unless handle
         raise "Could not resolve #{@selector} to DOM Element"
       end
 
-      call_options = {}
-      if timeout
-        call_options[:timeout] = (timeout - (Time.now - start_time) * 1000).to_i
-      end
+      call_options = {
+        timeout: (timeout_or_default - (Time.now - start_time) * 1000).to_i,
+      }
 
       begin
         block.call(handle, call_options)
@@ -130,6 +130,14 @@ module Playwright
       )
     end
 
+    def frame_locator(selector)
+      FrameLocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        frame_selector: "#{@selector} >> #{selector}",
+      )
+    end
+
     def element_handle(timeout: nil)
       @frame.wait_for_selector(@selector, strict: true, state: 'attached', timeout: timeout)
     end

data/lib/playwright/tracing_impl.rb

@@ -5,18 +5,18 @@ module Playwright
       @context = context
     end
 
-    def start(name: nil, screenshots: nil, snapshots: nil)
+    def start(name: nil, title: nil, screenshots: nil, snapshots: nil)
       params = {
         name: name,
         screenshots: screenshots,
         snapshots: snapshots,
       }.compact
       @channel.send_message_to_server('tracingStart', params)
-      @channel.send_message_to_server('tracingStartChunk')
+      @channel.send_message_to_server('tracingStartChunk', { title: title }.compact)
     end
 
-    def start_chunk
-      @channel.send_message_to_server('tracingStartChunk')
+    def start_chunk(title: nil)
+      @channel.send_message_to_server('tracingStartChunk', { title: title }.compact)
     end
 
     def stop_chunk(path: nil)
@@ -29,13 +29,10 @@ module Playwright
     end
 
     private def do_stop_chunk(path:)
-      resp = @channel.send_message_to_server('tracingStopChunk', save: !path.nil?)
-      artifact = ChannelOwners::Artifact.from_nullable(resp)
+      result = @channel.send_message_to_server_result('tracingStopChunk', save: !path.nil?, skipCompress: false)
+      artifact = ChannelOwners::Artifact.from_nullable(result['artifact'])
       return unless artifact
 
-      if @context.browser.send(:remote?)
-        artifact.update_as_remote
-      end
       artifact.save_as(path)
       artifact.delete
     end

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '1.16.0'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.16.0'
+  VERSION = '1.17.1'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.17.2'
 end

data/lib/playwright/video.rb

@@ -22,6 +22,9 @@ module Playwright
     end
 
     def path
+      if @page.send(:remote_connection?)
+        raise 'Path is not available when using browserType.connect(). Use save_as() to save a local copy.'
+      end
       wait_for_artifact_and do |artifact|
         artifact.absolute_path
       end