playwright-ruby-client 1.22.0 → 1.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82040f41eb8c972a8e3415aac148c27218e9fcbb00d7e09832bd75da506d2367
-  data.tar.gz: a42be0ab4e00bb0ef36516474cca8220147d8c635e44c581c799ee65e396721f
+  metadata.gz: 5d8cc3ad6fb1bd9c8a42f249085e91f92dbed26ebcbbd310559810299b60ea31
+  data.tar.gz: 6fb3450345d6f7bcbcbb19e3206244739f8aecf0813a94216e58df03674fb8e1
 SHA512:
-  metadata.gz: 615d15f014ca5f175d9da7504583693903d0ebd4c3d47522bf2f5c0add5aa01f26551300834b86cd944a2eacb2ef38062c341ec14f1177b7f517a16dab6e90fe
-  data.tar.gz: 97de038214b07abfbeb9eece923c0b031793b8939107df5f7b37268dbb4598c188dc88c4870766cf31d0bf28416610f46c996518a2f37fc8c73d5b672f713005
+  metadata.gz: b4e12e990b3a9df4532154ad62d6064c343664b75d8f29d088e6c28c00b5f22608d3de49c3568af2e2ac8689e9d9769e478e36571e7921d928c21eb3a18d9a56
+  data.tar.gz: 49f939af824f3affd9bbb011eb389238d5484a3f320fed6ad170bfb8c011ac351f6dba239f4e685d6b9058f4b72461fd5d1b5aee98835e34948eeef90b535dbc

data/documentation/docs/api/browser.md

@@ -21,6 +21,14 @@ end
 
 
 
+## browser_type
+
+```
+def browser_type
+```
+
+Get the browser type (chromium, firefox or webkit) that the browser belongs to.
+
 ## close
 
 ```
@@ -93,12 +101,16 @@ def new_context(
       offline: nil,
       permissions: nil,
       proxy: nil,
+      record_har_content: nil,
+      record_har_mode: nil,
       record_har_omit_content: nil,
       record_har_path: nil,
+      record_har_url_filter: nil,
       record_video_dir: nil,
       record_video_size: nil,
       reducedMotion: nil,
       screen: nil,
+      serviceWorkers: nil,
       storageState: nil,
       strictSelectors: nil,
       timezoneId: nil,
@@ -144,12 +156,16 @@ def new_page(
       offline: nil,
       permissions: nil,
       proxy: nil,
+      record_har_content: nil,
+      record_har_mode: nil,
       record_har_omit_content: nil,
       record_har_path: nil,
+      record_har_url_filter: nil,
       record_video_dir: nil,
       record_video_size: nil,
       reducedMotion: nil,
       screen: nil,
+      serviceWorkers: nil,
       storageState: nil,
       strictSelectors: nil,
       timezoneId: nil,

data/documentation/docs/api/browser_context.md

@@ -271,9 +271,9 @@ def route(url, handler, times: nil)
 Routing provides the capability to modify network requests that are made by any page in the browser context. Once route
 is enabled, every request matching the url pattern will stall unless it's continued, fulfilled or aborted.
 
-> NOTE: [Page#route](./page#route) will not intercept requests intercepted by Service Worker. See
+> NOTE: [BrowserContext#route](./browser_context#route) will not intercept requests intercepted by Service Worker. See
 [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when using
-request interception. Via `await context.addInitScript(() => delete window.navigator.serviceWorker);`
+request interception by setting `Browser.newContext.serviceWorkers` to `'block'`.
 
 An example of a naive handler that aborts all image requests:
 
@@ -315,6 +315,19 @@ To remove a route with its handler you can use [BrowserContext#unroute](./browse
 
 > NOTE: Enabling routing disables http cache.
 
+## route_from_har
+
+```
+def route_from_har(har, notFound: nil, update: nil, url: nil)
+```
+
+If specified the network requests that are made in the context will be served from the HAR file. Read more about
+[Replaying from HAR](https://playwright.dev/python/docs/network).
+
+Playwright will not serve requests intercepted by Service Worker from the HAR file. See
+[this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when using
+request interception by setting `Browser.newContext.serviceWorkers` to `'block'`.
+
 ## service_workers
 
 ```

data/documentation/docs/api/browser_type.md

@@ -131,12 +131,16 @@ def launch_persistent_context(
       offline: nil,
       permissions: nil,
       proxy: nil,
+      record_har_content: nil,
+      record_har_mode: nil,
       record_har_omit_content: nil,
       record_har_path: nil,
+      record_har_url_filter: nil,
       record_video_dir: nil,
       record_video_size: nil,
       reducedMotion: nil,
       screen: nil,
+      serviceWorkers: nil,
       slowMo: nil,
       strictSelectors: nil,
       timeout: nil,

data/documentation/docs/api/element_handle.md

@@ -504,11 +504,6 @@ element_handle.select_option(label: "blue")
 element_handle.select_option(value: ["red", "green", "blue"])
 ```
 
-```ruby
-# multiple selection for blue, red and second option
-element_handle.select_option(value: "blue", index: 2, label: "red")
-```
-
 
 
 ## select_text

data/documentation/docs/api/experimental/android_device.md

@@ -45,12 +45,16 @@ def launch_browser(
       noViewport: nil,
       offline: nil,
       permissions: nil,
+      record_har_content: nil,
+      record_har_mode: nil,
       record_har_omit_content: nil,
       record_har_path: nil,
+      record_har_url_filter: nil,
       record_video_dir: nil,
       record_video_size: nil,
       reducedMotion: nil,
       screen: nil,
+      serviceWorkers: nil,
       strictSelectors: nil,
       timezoneId: nil,
       userAgent: nil,

data/documentation/docs/api/locator.md

@@ -291,7 +291,19 @@ To send fine-grained keyboard events, use [Locator#type](./locator#type).
 def filter(has: nil, hasText: nil)
 ```
 
-This method narrows existing locator according to the options, for example filters by text.
+This method narrows existing locator according to the options, for example filters by text. It can be chained to filter
+multiple times.
+
+```ruby
+row_locator = page.locator("tr")
+# ...
+row_locator.
+    filter(has_text="text in column 1").
+    filter(has=page.locator("tr", has_text="column 2 button")).
+    screenshot
+```
+
+
 
 ## first
 
@@ -564,11 +576,6 @@ element.select_option(label: "blue")
 element.select_option(value: ["red", "green", "blue"])
 ```
 
-```ruby
-# multiple selection for blue, red and second option
-element.select_option(value: "blue", index: 2, label: "red")
-```
-
 
 
 ## select_text

data/documentation/docs/api/page.md

@@ -975,7 +975,7 @@ Once routing is enabled, every request matching the url pattern will stall unles
 > NOTE: The handler will only be called for the first url if the response is a redirect.
 > NOTE: [Page#route](./page#route) will not intercept requests intercepted by Service Worker. See
 [this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when using
-request interception. Via `await context.addInitScript(() => delete window.navigator.serviceWorker);`
+request interception by setting `Browser.newContext.serviceWorkers` to `'block'`.
 
 An example of a naive handler that aborts all image requests:
 
@@ -1013,6 +1013,19 @@ To remove a route with its handler you can use [Page#unroute](./page#unroute).
 
 > NOTE: Enabling routing disables http cache.
 
+## route_from_har
+
+```
+def route_from_har(har, notFound: nil, update: nil, url: nil)
+```
+
+If specified the network requests that are made in the page will be served from the HAR file. Read more about
+[Replaying from HAR](https://playwright.dev/python/docs/network).
+
+Playwright will not serve requests intercepted by Service Worker from the HAR file. See
+[this](https://github.com/microsoft/playwright/issues/1090) issue. We recommend disabling Service Workers when using
+request interception by setting `Browser.newContext.serviceWorkers` to `'block'`.
+
 ## screenshot
 
 ```

data/documentation/docs/api/request.md

@@ -56,7 +56,9 @@ Returns the [Frame](./frame) that initiated this request.
 def headers
 ```
 
-**DEPRECATED** Incomplete list of headers as seen by the rendering engine. Use [Request#all_headers](./request#all_headers) instead.
+An object with the request HTTP headers. The header names are lower-cased. Note that this method does not return
+security-related headers, including cookie-related ones. You can use [Request#all_headers](./request#all_headers) for complete list of
+headers that include `cookie` information.
 
 ## headers_array
 

data/documentation/docs/api/response.md

@@ -38,13 +38,24 @@ def frame
 
 Returns the [Frame](./frame) that initiated this response.
 
+## from_service_worker
+
+```
+def from_service_worker
+```
+
+Indicates whether this Response was fullfilled by a Service Worker's Fetch Handler (i.e. via
+[FetchEvent.respondWith](https://developer.mozilla.org/en-US/docs/Web/API/FetchEvent/respondWith)).
+
 ## headers
 
 ```
 def headers
 ```
 
-**DEPRECATED** Incomplete list of headers as seen by the rendering engine. Use [Response#all_headers](./response#all_headers) instead.
+An object with the response HTTP headers. The header names are lower-cased. Note that this method does not return
+security-related headers, including cookie-related ones. You can use [Response#all_headers](./response#all_headers) for complete list
+of headers that include `cookie` information.
 
 ## headers_array
 

data/documentation/docs/api/route.md

@@ -31,6 +31,7 @@ def handle(route, request)
   headers = request.headers
   headers['foo'] = 'bar' # set "foo" header
   headers['user-agent'] = 'Unknown Browser' # modify user-agent
+  headers.delete('bar') # remove "bar" header
 
   route.continue(headers: headers)
 end
@@ -39,6 +40,70 @@ page.route("**/*", method(:handle))
 
 
 
+## fallback
+
+```
+def fallback(headers: nil, method: nil, postData: nil, url: nil)
+```
+
+When several routes match the given pattern, they run in the order opposite to their registration. That way the last
+registered route can always override all the previos ones. In the example below, request will be handled by the
+bottom-most handler first, then it'll fall back to the previous one and in the end will be aborted by the first
+registered route.
+
+```ruby
+page.route("**/*", -> (route,_) { route.abort })  # Runs last.
+page.route("**/*", -> (route,_) { route.fallback })  # Runs second.
+page.route("**/*", -> (route,_) { route.fallback })  # Runs first.
+```
+
+Registering multiple routes is useful when you want separate handlers to handle different kinds of requests, for example
+API calls vs page resources or GET requests vs POST requests as in the example below.
+
+```ruby
+# Handle GET requests.
+def handle_post(route, request)
+  if request.method != "GET"
+    route.fallback
+    return
+  end
+
+  # Handling GET only.
+  # ...
+end
+
+# Handle POST requests.
+def handle_post(route)
+  if request.method != "POST"
+    route.fallback
+    return
+  end
+
+  # Handling POST only.
+  # ...
+end
+
+page.route("**/*", handle_get)
+page.route("**/*", handle_post)
+```
+
+One can also modify request while falling back to the subsequent handler, that way intermediate route handler can modify
+url, method, headers and postData of the request.
+
+```ruby
+def handle(route, request)
+  # override headers
+  headers = request.headers
+  headers['foo'] = 'bar' # set "foo" header
+  headers['user-agent'] = 'Unknown Browser' # modify user-agent
+  headers.delete('bar') # remove "bar" header
+
+  route.fallback(headers: headers)
+end
+```
+
+
+
 ## fulfill
 
 ```

data/documentation/docs/include/api_coverage.md

@@ -27,6 +27,7 @@
 * body
 * finished
 * frame
+* from_service_worker
 * headers
 * headers_array
 * header_value
@@ -45,6 +46,7 @@
 
 * abort
 * continue
+* fallback
 * fulfill
 * request
 
@@ -280,6 +282,7 @@
 * query_selector_all
 * reload
 * route
+* route_from_har
 * screenshot
 * select_option
 * set_checked
@@ -339,6 +342,7 @@
 * new_page
 * pages
 * route
+* route_from_har
 * service_workers
 * set_default_navigation_timeout
 * set_default_timeout
@@ -360,6 +364,7 @@
 
 ## Browser
 
+* browser_type
 * close
 * contexts
 * connected?
@@ -454,9 +459,6 @@
 * locator
 * nth
 
-## LocalUtils
-
-
 ## APIResponse
 
 * body

data/lib/playwright/channel.rb

@@ -37,13 +37,11 @@ module Playwright
 
     # @param method [String]
     # @param params [Hash]
-    # @returns nil
+    # @returns [Concurrent::Promises::Future]
     def async_send_message_to_server(method, params = {})
       with_logging do |metadata|
         @connection.async_send_message_to_server(@guid, method, params, metadata: metadata)
       end
-
-      nil
     end
 
     private def with_logging(&block)

data/lib/playwright/channel_owners/browser.rb

@@ -5,6 +5,7 @@ module Playwright
     include Utils::PrepareBrowserContextOptions
 
     private def after_initialize
+      @browser_type = @parent
       @connected = true
       @closed_or_closing = false
       @should_close_connection_on_close = false
@@ -17,6 +18,10 @@ module Playwright
       @contexts.to_a
     end
 
+    def browser_type
+      @browser_type
+    end
+
     def connected?
       @connected
     end
@@ -30,6 +35,7 @@ module Playwright
       @contexts << context
       context.browser = self
       context.options = params
+      context.send(:update_browser_type, @browser_type)
       return context unless block
 
       begin
@@ -54,6 +60,13 @@ module Playwright
       end
     end
 
+    private def update_browser_type(browser_type)
+      @browser_type = browser_type
+      @contexts.each do |context|
+        context.send(:update_browser_type, browser_type)
+      end
+    end
+
     def close
       return if @closed_or_closing
       @closed_or_closing = true

data/lib/playwright/channel_owners/browser_context.rb

@@ -2,6 +2,8 @@ module Playwright
   # @ref https://github.com/microsoft/playwright-python/blob/master/playwright/_impl/_browser_context.py
   define_channel_owner :BrowserContext do
     include Utils::Errors::SafeCloseError
+    include Utils::PrepareBrowserContextOptions
+
     attr_accessor :browser
     attr_writer :owner_page, :options
     attr_reader :tracing, :request
@@ -17,12 +19,17 @@ module Playwright
 
       @tracing = ChannelOwners::Tracing.from(@initializer['tracing'])
       @request = ChannelOwners::APIRequestContext.from(@initializer['APIRequestContext'])
+      @har_recorders = {}
 
       @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']) )})
       @channel.on('route', ->(params) {
-        on_route(ChannelOwners::Route.from(params['route']), ChannelOwners::Request.from(params['request']))
+        Concurrent::Promises.future {
+          on_route(ChannelOwners::Route.from(params['route']), ChannelOwners::Request.from(params['request']))
+        }.rescue do |err|
+          puts err, err.backtrace
+        end
       })
       @channel.on('backgroundPage', ->(params) {
         on_background_page(ChannelOwners::Page.from(params['page']))
@@ -55,6 +62,16 @@ module Playwright
       @closed_promise = Concurrent::Promises.resolvable_future
     end
 
+    private def update_browser_type(browser_type)
+      @browser_type = browser_type
+      if @options[:recordHar]
+        @har_recorders[''] = {
+          path: @options[:recordHar][:path],
+          content: @options[:recordHar][:content]
+        }
+      end
+    end
+
     private def on_page(page)
       @pages << page
       emit(Events::BrowserContext::Page, page)
@@ -73,19 +90,29 @@ module Playwright
       wrapped_route = PlaywrightApi.wrap(route)
       wrapped_request = PlaywrightApi.wrap(request)
 
-      handler_entry = @routes.find do |entry|
-        entry.match?(request.url)
+      handled = @routes.any? do |handler_entry|
+        next false unless handler_entry.match?(request.url)
+
+        promise = Concurrent::Promises.resolvable_future
+        route.send(:set_handling_future, promise)
+
+        promise_handled = Concurrent::Promises.zip(
+          promise,
+          handler_entry.async_handle(wrapped_route, wrapped_request)
+        ).value!.first
+
+        promise_handled
       end
 
-      if handler_entry
-        handler_entry.async_handle(wrapped_route, wrapped_request)
+      @routes.reject!(&:expired?)
+      if @routes.count == 0
+        @channel.async_send_message_to_server('setNetworkInterceptionEnabled', enabled: false)
+      end
 
-        @routes.reject!(&:expired?)
-        if @routes.count == 0
-          @channel.async_send_message_to_server('setNetworkInterceptionEnabled', enabled: false)
+      unless handled
+        route.send(:async_continue_route).rescue do |err|
+          puts err, err.backtrace
         end
-      else
-        route.continue
       end
     end
 
@@ -266,6 +293,37 @@ module Playwright
       end
     end
 
+    private def record_into_har(har, page, notFound:, url:)
+      params = {
+        options: prepare_record_har_options(
+          record_har_path: har,
+          record_har_content: "attach",
+          record_har_mode: "minimal",
+          record_har_url_filter: url,
+        )
+      }
+      if page
+        params[:page] = page.channel
+      end
+      har_id = @channel.send_message_to_server('harStart', params)
+      @har_recorders[har_id] = { path: har, content: 'attach' }
+    end
+
+    def route_from_har(har, notFound: nil, update: nil, url: nil)
+      if update
+        record_into_har(har, nil, notFound: notFound, url: url)
+        return
+      end
+
+      router = HarRouter.create(
+        @connection.local_utils,
+        har.to_s,
+        notFound || "abort",
+        url_match: url,
+      )
+      router.add_context_route(self)
+    end
+
     def expect_event(event, predicate: nil, timeout: nil, &block)
       wait_helper = WaitHelper.new
       wait_helper.reject_on_timeout(timeout || @timeout_settings.timeout, "Timeout while waiting for event \"#{event}\"")
@@ -283,9 +341,19 @@ module Playwright
     end
 
     def close
-      if @options && @options.key?(:recordHar)
-        har = ChannelOwners::Artifact.from(@channel.send_message_to_server('harExport'))
-        har.save_as(@options[:recordHar][:path])
+      @har_recorders.each do |har_id, params|
+        har = ChannelOwners::Artifact.from(@channel.send_message_to_server('harExport', harId: har_id))
+        # Server side will compress artifact if content is attach or if file is .zip.
+        compressed = params[:content] == "attach" || params[:path].end_with?('.zip')
+        need_comppressed = params[:path].end_with?('.zip')
+        if compressed && !need_comppressed
+          tmp_path = "#{params[:path]}.tmp"
+          har.save_as(tmp_path)
+          @connection.local_utils.har_unzip(tmp_path, params[:path])
+        else
+          har.save_as(params[:path])
+        end
+
         har.delete
       end
       @channel.send_message_to_server('close')

data/lib/playwright/channel_owners/browser_type.rb

@@ -13,6 +13,7 @@ module Playwright
     def launch(options, &block)
       resp = @channel.send_message_to_server('launch', options.compact)
       browser = ChannelOwners::Browser.from(resp)
+      browser.send(:update_browser_type, self)
       return browser unless block
 
       begin
@@ -29,6 +30,8 @@ module Playwright
 
       resp = @channel.send_message_to_server('launchPersistentContext', params.compact)
       context = ChannelOwners::Browser.from(resp)
+      context.options = params
+      context.send(:update_browser_type, self)
       return context unless block
 
       begin
@@ -54,6 +57,7 @@ module Playwright
 
       result = @channel.send_message_to_server_result('connectOverCDP', params)
       browser = ChannelOwners::Browser.from(result['browser'])
+      browser.send(:update_browser_type, self)
 
       if result['defaultContext']
         context = ChannelOwners::BrowserContext.from(result['defaultContext'])

data/lib/playwright/channel_owners/frame.rb

@@ -25,11 +25,25 @@ module Playwright
     private def on_load_state(add:, remove:)
       if add
         @load_states << add
-        @event_emitter.emit('loadstate', add)
+
+        # Original JS version of Playwright emit event here.
+        # @event_emitter.emit('loadstate', add)
       end
       if remove
         @load_states.delete(remove)
       end
+      unless @parent_frame
+        if add == 'load'
+          @page&.emit(Events::Page::Load, @page)
+        elsif add == 'domcontentloaded'
+          @page&.emit(Events::Page::DOMContentLoaded, @page)
+        end
+      end
+
+      # emit to waitForLoadState(load) listeners explicitly after waitForEvent(load) listeners
+      if add
+        @event_emitter.emit('loadstate', add)
+      end
     end
 
     private def on_frame_navigated(event)
@@ -38,7 +52,7 @@ module Playwright
       @event_emitter.emit('navigated', event)
 
       unless event['error']
-        @page&.emit('framenavigated', self)
+        @page&.emit(Events::Page::FrameNavigated, self)
       end
     end
 

data/lib/playwright/channel_owners/local_utils.rb

@@ -10,5 +10,34 @@ module Playwright
       @channel.send_message_to_server('zip', params)
       nil
     end
+
+
+    # @param file [String]
+    # @return [String] har ID
+    def har_open(file)
+      @channel.send_message_to_server('harOpen', file: file)
+    end
+
+    def har_lookup(har_id:, url:, method:, headers:, is_navigation_request:, post_data: nil)
+      params = {
+        harId: har_id,
+        url: url,
+        method: method,
+        headers: headers,
+        postData: post_data,
+        isNavigationRequest: is_navigation_request,
+      }.compact
+
+      @channel.send_message_to_server_result('harLookup', params)
+    end
+
+    # @param har_id [String]
+    def async_har_close(har_id)
+      @channel.async_send_message_to_server('harClose', harId: har_id)
+    end
+
+    def har_unzip(zip_file, har_file)
+      @channel.send_message_to_server('harUnzip', zipFile: zip_file, harFile: har_file)
+    end
   end
 end