playwright-ruby-client 1.15.1 → 1.17.beta1

data/lib/playwright/channel_owners/api_request_context.rb

@@ -0,0 +1,4 @@
+module Playwright
+  define_channel_owner :APIRequestContext do
+  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

@@ -72,6 +72,11 @@ module Playwright
 
       if @routes.none? { |handler_entry| handler_entry.handle(wrapped_route, wrapped_request) }
         route.continue
+      else
+        @routes.reject!(&:expired?)
+        if @routes.count == 0
+          @channel.async_send_message_to_server('setNetworkInterceptionEnabled', enabled: false)
+        end
       end
     end
 
@@ -271,9 +276,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,4 +1,8 @@
+require_relative './api_request_context'
+
 module Playwright
-  define_channel_owner :FetchRequest do
+  module ChannelOwners
+    class FetchRequest < APIRequestContext
+    end
   end
 end

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)
@@ -593,7 +597,9 @@ module Playwright
     end
 
     def wait_for_timeout(timeout)
-      sleep(timeout / 1000.0)
+      @channel.send_message_to_server('waitForTimeout', timeout: timeout)
+
+      nil
     end
 
     def wait_for_function(pageFunction, arg: nil, polling: nil, timeout: nil)

data/lib/playwright/channel_owners/page.rb

@@ -100,6 +100,11 @@ module Playwright
 
       if @routes.none? { |handler_entry| handler_entry.handle(wrapped_route, wrapped_request) }
         @browser_context.send(:on_route, route, request)
+      else
+        @routes.reject!(&:expired?)
+        if @routes.count == 0
+          @channel.async_send_message_to_server('setNetworkInterceptionEnabled', enabled: false)
+        end
       end
     end
 
@@ -133,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'],
@@ -147,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
 
@@ -256,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
@@ -563,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
@@ -920,6 +923,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/channel_owners/request.rb

@@ -84,39 +84,27 @@ module Playwright
 
     # @return [RawHeaders|nil]
     private def actual_headers
-      @actual_headers ||= response&.send(:raw_request_headers)
+      @actual_headers ||= raw_request_headers
+    end
+
+    private def raw_request_headers
+      RawHeaders.new(@channel.send_message_to_server('rawRequestHeaders'))
     end
 
     def all_headers
-      if actual_headers
-        actual_headers.headers
-      else
-        @provisional_headers.headers
-      end
+      actual_headers.headers
     end
 
     def headers_array
-      if actual_headers
-        actual_headers.headers_array
-      else
-        @provisional_headers.headers_array
-      end
+      actual_headers.headers_array
     end
 
     def header_value(name)
-      if actual_headers
-        actual_headers.get(name)
-      else
-        @provisional_headers.get(name)
-      end
+      actual_headers.get(name)
     end
 
     def header_values(name)
-      if actual_headers
-        actual_headers.get_all(name)
-      else
-        @provisional_headers.get_all(name)
-      end
+      actual_headers.get_all(name)
     end
 
     def sizes

data/lib/playwright/channel_owners/response.rb

@@ -48,10 +48,6 @@ module Playwright
       @actual_headers ||= raw_response_headers
     end
 
-    private def raw_request_headers
-      RawHeaders.new(@channel.send_message_to_server('rawRequestHeaders'))
-    end
-
     private def raw_response_headers
       RawHeaders.new(@channel.send_message_to_server('rawResponseHeaders'))
     end

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
@@ -303,6 +311,10 @@ module Playwright
         trial: trial)
     end
 
+    def wait_for(state: nil, timeout: nil)
+      @frame.wait_for_selector(@selector, strict: true, state: state, timeout: timeout)
+    end
+
     def set_checked(checked, **options)
       if checked
         check(**options)

data/lib/playwright/route_handler.rb

@@ -6,17 +6,25 @@ module Playwright
       end
 
       def handle
-        return false if @count <= 0
+        return false if expired?
 
         @count = @count - 1
         true
       end
+
+      def expired?
+        @count <= 0
+      end
     end
 
     class StubCounter
       def handle
         true
       end
+
+      def expired?
+        false
+      end
     end
 
     # @param url [String]
@@ -46,6 +54,10 @@ module Playwright
       end
     end
 
+    def expired?
+      @counter.expired?
+    end
+
     def same_value?(url:, handler: nil)
       if handler
         @url_value == url && @handler == handler

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.15.1'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.15.2'
+  VERSION = '1.17.beta1'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.17.0'
 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

data/lib/playwright.rb

@@ -135,13 +135,14 @@ module Playwright
 
     transport = WebSocketTransport.new(ws_endpoint: ws_endpoint)
     connection = Connection.new(transport)
+    connection.mark_as_remote
     connection.async_run
 
     execution =
       begin
         playwright = connection.initialize_playwright
         browser = playwright.send(:pre_launched_browser)
-        browser.send(:update_as_remote)
+        browser.should_close_connection_on_close!
         Execution.new(connection, PlaywrightApi.wrap(playwright), PlaywrightApi.wrap(browser))
       rescue
         connection.stop

data/lib/playwright_api/api_request_context.rb

@@ -0,0 +1,149 @@
+module Playwright
+  # This API is used for the Web API testing. You can use it to trigger API endpoints, configure micro-services, prepare
+  # environment or the service to your e2e test. When used on `Page` or a `BrowserContext`, this API will automatically use
+  # the cookies from the corresponding `BrowserContext`. This means that if you log in using this API, your e2e test will be
+  # logged in and vice versa.
+  class APIRequestContext < PlaywrightApi
+
+    # Sends HTTP(S) [DELETE](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/DELETE) request and returns its
+    # response. The method will populate request cookies from the context and update context cookies from the response. The
+    # method will automatically follow redirects.
+    def delete(
+          url,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+      raise NotImplementedError.new('delete is not implemented yet.')
+    end
+
+    # All responses returned by [`method: APIRequestContext.get`] and similar methods are stored in the memory, so that you
+    # can later call [`method: APIResponse.body`]. This method discards all stored responses, and makes
+    # [`method: APIResponse.body`] throw "Response disposed" error.
+    def dispose
+      raise NotImplementedError.new('dispose is not implemented yet.')
+    end
+
+    # Sends HTTP(S) request and returns its response. The method will populate request cookies from the context and update
+    # context cookies from the response. The method will automatically follow redirects.
+    def fetch(
+          urlOrRequest,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          method: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+      raise NotImplementedError.new('fetch is not implemented yet.')
+    end
+
+    # Sends HTTP(S) [GET](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/GET) request and returns its response. The
+    # method will populate request cookies from the context and update context cookies from the response. The method will
+    # automatically follow redirects.
+    def get(
+          url,
+          failOnStatusCode: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          params: nil,
+          timeout: nil)
+      raise NotImplementedError.new('get is not implemented yet.')
+    end
+
+    # Sends HTTP(S) [HEAD](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/HEAD) request and returns its response.
+    # The method will populate request cookies from the context and update context cookies from the response. The method will
+    # automatically follow redirects.
+    def head(
+          url,
+          failOnStatusCode: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          params: nil,
+          timeout: nil)
+      raise NotImplementedError.new('head is not implemented yet.')
+    end
+
+    # Sends HTTP(S) [PATCH](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH) request and returns its response.
+    # The method will populate request cookies from the context and update context cookies from the response. The method will
+    # automatically follow redirects.
+    def patch(
+          url,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+      raise NotImplementedError.new('patch is not implemented yet.')
+    end
+
+    # Sends HTTP(S) [POST](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST) request and returns its response.
+    # The method will populate request cookies from the context and update context cookies from the response. The method will
+    # automatically follow redirects.
+    def post(
+          url,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+      raise NotImplementedError.new('post is not implemented yet.')
+    end
+
+    # Sends HTTP(S) [PUT](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT) request and returns its response. The
+    # method will populate request cookies from the context and update context cookies from the response. The method will
+    # automatically follow redirects.
+    def put(
+          url,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
+      raise NotImplementedError.new('put is not implemented yet.')
+    end
+
+    # Returns storage state for this request context, contains current cookies and local storage snapshot if it was passed to
+    # the constructor.
+    def storage_state(path: nil)
+      raise NotImplementedError.new('storage_state is not implemented yet.')
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
+    end
+
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
+    end
+  end
+end