playwright-ruby-client 1.28.1 → 1.29.1.alpha1

data/documentation/docs/api/web_socket.md

@@ -4,6 +4,7 @@ sidebar_position: 10
 
 # WebSocket
 
+
 The [WebSocket](./web_socket) class represents websocket connections in the page.
 
 ## closed?
@@ -12,6 +13,7 @@ The [WebSocket](./web_socket) class represents websocket connections in the page
 def closed?
 ```
 
+
 Indicates that the web socket has been closed.
 
 ## url
@@ -20,6 +22,7 @@ Indicates that the web socket has been closed.
 def url
 ```
 
+
 Contains the URL of the WebSocket.
 
 ## expect_event
@@ -28,6 +31,7 @@ Contains the URL of the WebSocket.
 def expect_event(event, predicate: nil, timeout: nil, &block)
 ```
 
+
 Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
 value. Will throw an error if the webSocket is closed before the event is fired. Returns the event data value.
 
@@ -37,8 +41,9 @@ value. Will throw an error if the webSocket is closed before the event is fired.
 def wait_for_event(event, predicate: nil, timeout: nil, &block)
 ```
 
-> NOTE: In most cases, you should use [WebSocket#wait_for_event](./web_socket#wait_for_event).
 
-Waits for given `event` to fire. If predicate is provided, it passes event's value into the `predicate` function and
-waits for `predicate(event)` to return a truthy value. Will throw an error if the socket is closed before the `event` is
-fired.
+**NOTE**: In most cases, you should use [WebSocket#wait_for_event](./web_socket#wait_for_event).
+
+Waits for given `event` to fire. If predicate is provided, it passes
+event's value into the `predicate` function and waits for `predicate(event)` to return a truthy value.
+Will throw an error if the socket is closed before the `event` is fired.

data/documentation/docs/api/worker.md

@@ -4,6 +4,7 @@ sidebar_position: 10
 
 # Worker
 
+
 The Worker class represents a [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API). `worker`
 event is emitted on the page object to signal a worker creation. `close` event is emitted on the worker object when the
 worker is gone.
@@ -22,22 +23,20 @@ page.workers.each do |worker|
 end
 ```
 
-
-
 ## evaluate
 
 ```
 def evaluate(expression, arg: nil)
 ```
 
+
 Returns the return value of `expression`.
 
-If the function passed to the [Worker#evaluate](./worker#evaluate) returns a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise), then [Worker#evaluate](./worker#evaluate) would
-wait for the promise to resolve and return its value.
+If the function passed to the [Worker#evaluate](./worker#evaluate) returns a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise), then [Worker#evaluate](./worker#evaluate) would wait for the promise
+to resolve and return its value.
 
-If the function passed to the [Worker#evaluate](./worker#evaluate) returns a non-[Serializable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#description) value, then
-[Worker#evaluate](./worker#evaluate) returns `undefined`. Playwright also supports transferring some additional values that are
-not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.
+If the function passed to the [Worker#evaluate](./worker#evaluate) returns a non-[Serializable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#description) value, then [Worker#evaluate](./worker#evaluate) returns `undefined`. Playwright also supports transferring some
+additional values that are not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.
 
 ## evaluate_handle
 
@@ -45,13 +44,15 @@ not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.
 def evaluate_handle(expression, arg: nil)
 ```
 
+
 Returns the return value of `expression` as a [JSHandle](./js_handle).
 
-The only difference between [Worker#evaluate](./worker#evaluate) and [Worker#evaluate_handle](./worker#evaluate_handle) is that
-[Worker#evaluate_handle](./worker#evaluate_handle) returns [JSHandle](./js_handle).
+The only difference between [Worker#evaluate](./worker#evaluate) and
+[Worker#evaluate_handle](./worker#evaluate_handle) is that [Worker#evaluate_handle](./worker#evaluate_handle)
+returns [JSHandle](./js_handle).
 
-If the function passed to the [Worker#evaluate_handle](./worker#evaluate_handle) returns a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise), then
-[Worker#evaluate_handle](./worker#evaluate_handle) would wait for the promise to resolve and return its value.
+If the function passed to the [Worker#evaluate_handle](./worker#evaluate_handle) returns a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise), then [Worker#evaluate_handle](./worker#evaluate_handle) would wait for
+the promise to resolve and return its value.
 
 ## url
 

data/documentation/docs/include/api_coverage.md

@@ -47,6 +47,7 @@
 * abort
 * continue
 * fallback
+* fetch
 * fulfill
 * request
 
@@ -418,6 +419,7 @@
 
 ## Locator
 
+* all
 * all_inner_texts
 * all_text_contents
 * blur

data/lib/playwright/channel_owners/api_request_context.rb

@@ -56,6 +56,42 @@ module Playwright
       if [ChannelOwners::Request, String].none? { |type| urlOrRequest.is_a?(type) }
         raise ArgumentError.new("First argument must be either URL string or Request")
       end
+      if urlOrRequest.is_a?(ChannelOwners::Request)
+        request = urlOrRequest
+        url = nil
+      else
+        url = urlOrRequest
+        request = nil
+      end
+      _inner_fetch(
+        request,
+        url,
+        data: data,
+        failOnStatusCode: failOnStatusCode,
+        form: form,
+        headers: headers,
+        ignoreHTTPSErrors: ignoreHTTPSErrors,
+        maxRedirects: maxRedirects,
+        method: method,
+        multipart: multipart,
+        params: params,
+        timeout: timeout,
+      )
+    end
+
+    private def _inner_fetch(
+          request,
+          url,
+          data: nil,
+          failOnStatusCode: nil,
+          form: nil,
+          headers: nil,
+          ignoreHTTPSErrors: nil,
+          maxRedirects: nil,
+          method: nil,
+          multipart: nil,
+          params: nil,
+          timeout: nil)
       if [data, form, multipart].compact.count > 1
         raise ArgumentError.new("Only one of 'data', 'form' or 'multipart' can be specified")
       end
@@ -63,10 +99,9 @@ module Playwright
         raise ArgumentError.new("'maxRedirects' should be greater than or equal to '0'")
       end
 
-      request = urlOrRequest.is_a?(ChannelOwners::Request) ? urlOrRequest : nil
       headers_obj = headers || request&.headers
       fetch_params = {
-        url: request&.url || urlOrRequest,
+        url: url || request.url,
         params: object_to_array(params),
         method: method || request&.method || 'GET',
         headers: headers_obj ? HttpHeaders.new(headers_obj).as_serialized : nil,

data/lib/playwright/channel_owners/browser_context.rb

@@ -24,13 +24,7 @@ module Playwright
       @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) {
-        Concurrent::Promises.future {
-          on_route(ChannelOwners::Route.from(params['route']))
-        }.rescue do |err|
-          puts err, err.backtrace
-        end
-      })
+      @channel.on('route', ->(params) { on_route(ChannelOwners::Route.from(params['route'])) })
       @channel.on('backgroundPage', ->(params) {
         on_background_page(ChannelOwners::Page.from(params['page']))
       })
@@ -93,31 +87,33 @@ module Playwright
       # It is not desired to use PlaywrightApi.wrap directly.
       # However it is a little difficult to define wrapper for `handler` parameter in generate_api.
       # Just a workaround...
-      wrapped_route = PlaywrightApi.wrap(route)
-
-      handled = @routes.any? do |handler_entry|
-        next false unless handler_entry.match?(route.request.url)
+      Concurrent::Promises.future(PlaywrightApi.wrap(route)) do |wrapped_route|
+        handled = @routes.any? do |handler_entry|
+          next false unless handler_entry.match?(route.request.url)
 
-        promise = Concurrent::Promises.resolvable_future
-        route.send(:set_handling_future, promise)
+          promise = Concurrent::Promises.resolvable_future
+          route.send(:set_handling_future, promise)
 
-        promise_handled = Concurrent::Promises.zip(
-          promise,
-          handler_entry.async_handle(wrapped_route)
-        ).value!.first
+          promise_handled = Concurrent::Promises.zip(
+            promise,
+            handler_entry.async_handle(wrapped_route)
+          ).value!.first
 
-        promise_handled
-      end
+          promise_handled
+        end
 
-      @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)
+        end
 
-      unless handled
-        route.send(:async_continue_route).rescue do |err|
-          puts err, err.backtrace
+        unless handled
+          route.send(:async_continue_route).rescue do |err|
+            puts err, err.backtrace
+          end
         end
+      end.rescue do |err|
+        puts err, err.backtrace
       end
     end
 

data/lib/playwright/channel_owners/page.rb

@@ -59,13 +59,7 @@ module Playwright
       @channel.on('pageError', ->(params) {
         emit(Events::Page::PageError, Error.parse(params['error']['error']))
       })
-      @channel.on('route', ->(params) {
-        Concurrent::Promises.future {
-          on_route(ChannelOwners::Route.from(params['route']))
-        }.rescue do |err|
-          puts err, err.backtrace
-        end
-      })
+      @channel.on('route', ->(params) { on_route(ChannelOwners::Route.from(params['route'])) })
       @channel.on('video', method(:on_video))
       @channel.on('webSocket', ->(params) {
         emit(Events::Page::WebSocket, ChannelOwners::WebSocket.from(params['webSocket']))
@@ -108,29 +102,31 @@ module Playwright
       # It is not desired to use PlaywrightApi.wrap directly.
       # However it is a little difficult to define wrapper for `handler` parameter in generate_api.
       # Just a workaround...
-      wrapped_route = PlaywrightApi.wrap(route)
+      Concurrent::Promises.future(PlaywrightApi.wrap(route)) do |wrapped_route|
+        handled = @routes.any? do |handler_entry|
+          next false unless handler_entry.match?(route.request.url)
 
-      handled = @routes.any? do |handler_entry|
-        next false unless handler_entry.match?(route.request.url)
+          promise = Concurrent::Promises.resolvable_future
+          route.send(:set_handling_future, promise)
 
-        promise = Concurrent::Promises.resolvable_future
-        route.send(:set_handling_future, promise)
+          promise_handled = Concurrent::Promises.zip(
+            promise,
+            handler_entry.async_handle(wrapped_route)
+          ).value!.first
 
-        promise_handled = Concurrent::Promises.zip(
-          promise,
-          handler_entry.async_handle(wrapped_route)
-        ).value!.first
-
-        promise_handled
-      end
+          promise_handled
+        end
 
-      @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)
+        end
 
-      unless handled
-        @browser_context.send(:on_route, route)
+        unless handled
+          @browser_context.send(:on_route, route)
+        end
+      end.rescue do |err|
+        puts err, err.backtrace
       end
     end
 
@@ -178,6 +174,20 @@ module Playwright
       video.send(:set_artifact, artifact)
     end
 
+    # @override
+    private def perform_event_emitter_callback(event, callback, args)
+      should_callback_async = [
+        Events::Page::Dialog,
+        Events::Page::Response,
+      ].freeze
+
+      if should_callback_async.include?(event)
+        Concurrent::Promises.future { super }
+      else
+        super
+      end
+    end
+
     def context
       @browser_context
     end

data/lib/playwright/channel_owners/route.rb

@@ -31,21 +31,27 @@ module Playwright
           body: nil,
           contentType: nil,
           headers: nil,
+          json: nil,
           path: nil,
           status: nil,
           response: nil)
       handling_with_result(true) do
-        params = {
-          contentType: contentType,
-          status: status,
-        }.compact
+        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
-          params[:status] ||= response.status
-          params[:headers] ||= response.headers
+          option_status ||= response.status
+          option_headers ||= response.headers
 
-          if !body && !path && response.is_a?(APIResponse)
+          if !body && !path && response.is_a?(APIResponseImpl)
             if response.send(:_request).send(:same_connection?, self)
               params[:fetchResponseUid] = response.send(:fetch_uid)
             else
@@ -63,9 +69,11 @@ module Playwright
             nil
           end
 
-        param_headers = headers || {}
+        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
@@ -81,6 +89,7 @@ module Playwright
           param_headers['content-length'] ||= content.length.to_s
         end
 
+        params[:status] = option_status || 200
         params[:headers] = HttpHeaders.new(param_headers).as_serialized
 
         @channel.async_send_message_to_server('fulfill', params)
@@ -100,6 +109,17 @@ module Playwright
       end
     end
 
+    def fetch(headers: nil, method: nil, postData: nil, url: nil)
+      api_request_context = request.frame.page.context.request
+      api_request_context.send(:_inner_fetch,
+        request,
+        url,
+        headers: headers,
+        method: method,
+        data: postData,
+      )
+    end
+
     def continue(headers: nil, method: nil, postData: nil, url: nil)
       overrides = {
         headers: headers,

data/lib/playwright/event_emitter.rb

@@ -38,7 +38,7 @@ module Playwright
     def emit(event, *args)
       handled = false
       (@__event_emitter ||= {})[event.to_s]&.each do |callback|
-        callback.call(*args)
+        perform_event_emitter_callback(event, callback, args)
         handled = true
       end
       handled
@@ -48,6 +48,11 @@ module Playwright
       ((@__event_emitter ||= {})[event.to_s] ||= Set.new).count
     end
 
+    # can be overriden
+    private def perform_event_emitter_callback(event, callback, args)
+      callback.call(*args)
+    end
+
     # @param event [String]
     # @param callback [Proc]
     def on(event, callback)

data/lib/playwright/locator_impl.rb

@@ -263,6 +263,14 @@ module Playwright
       @frame.channel.send_message_to_server('blur', params)
     end
 
+    def all
+      Enumerator.new do |out|
+        count.times do |i|
+          out << nth(i)
+        end
+      end
+    end
+
     def count
       @frame.eval_on_selector_all(@selector, 'ee => ee.length')
     end

data/lib/playwright/select_option_values.rb

@@ -43,6 +43,8 @@ module Playwright
 
       if key == :element
         values.map(&:channel)
+      elsif key == :value
+        values.map { |value| { valueOrLabel: value } }
       else
         values.map { |value| { key => value } }
       end

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '1.28.1'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.28.1'
+  VERSION = '1.29.1.alpha1'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.29.1'
 end

data/lib/playwright_api/accessibility.rb

@@ -1,7 +1,4 @@
 module Playwright
-  # **DEPRECATED** This class is deprecated. Please use other libraries such as [Axe](https://www.deque.com/axe/) if you
-  # need to test page accessibility. See our Node.js [guide](https://playwright.dev/docs/accessibility-testing) for
-  # integration with Axe.
   #
   # The Accessibility class provides methods for inspecting Chromium's accessibility tree. The accessibility tree is used by
   # assistive technology such as [screen readers](https://en.wikipedia.org/wiki/Screen_reader) or
@@ -10,23 +7,22 @@ module Playwright
   # Accessibility is a very platform-specific thing. On different platforms, there are different screen readers that might
   # have wildly different output.
   #
-  # Rendering engines of Chromium, Firefox and WebKit have a concept of "accessibility tree", which is then translated into
-  # different platform-specific APIs. Accessibility namespace gives access to this Accessibility Tree.
+  # Rendering engines of Chromium, Firefox and WebKit have a concept of "accessibility tree", which is then translated into different
+  # platform-specific APIs. Accessibility namespace gives access to this Accessibility Tree.
   #
-  # Most of the accessibility tree gets filtered out when converting from internal browser AX Tree to Platform-specific
-  # AX-Tree or by assistive technologies themselves. By default, Playwright tries to approximate this filtering, exposing
-  # only the "interesting" nodes of the tree.
+  # Most of the accessibility tree gets filtered out when converting from internal browser AX Tree to Platform-specific AX-Tree or by
+  # assistive technologies themselves. By default, Playwright tries to approximate this filtering, exposing only the
+  # "interesting" nodes of the tree.
   class Accessibility < PlaywrightApi
 
-    # **DEPRECATED** This method is deprecated. Please use other libraries such as [Axe](https://www.deque.com/axe/) if you
-    # need to test page accessibility. See our Node.js [guide](https://playwright.dev/docs/accessibility-testing) for
-    # integration with Axe.
     #
     # Captures the current state of the accessibility tree. The returned object represents the root accessible node of the
     # page.
     #
-    # > NOTE: The Chromium accessibility tree contains nodes that go unused on most platforms and by most screen readers.
-    # Playwright will discard them as well for an easier to process tree, unless `interestingOnly` is set to `false`.
+    # **NOTE**: The Chromium accessibility tree contains nodes that go unused on most platforms and by most screen readers. Playwright
+    # will discard them as well for an easier to process tree, unless `interestingOnly` is set to `false`.
+    #
+    # **Usage**
     #
     # An example of dumping the entire accessibility tree:
     #

data/lib/playwright_api/android.rb

@@ -1,10 +1,10 @@
 module Playwright
+  #
   # Playwright has **experimental** support for Android automation. This includes Chrome for Android and Android WebView.
   #
   # *Requirements*
   # - Android device or AVD Emulator.
-  # - [ADB daemon](https://developer.android.com/studio/command-line/adb) running and authenticated with your device.
-  #   Typically running `adb devices` is all you need to do.
+  # - [ADB daemon](https://developer.android.com/studio/command-line/adb) running and authenticated with your device. Typically running `adb devices` is all you need to do.
   # - [`Chrome 87`](https://play.google.com/store/apps/details?id=com.android.chrome) or newer installed on the device
   # - "Enable command line on non-rooted devices" enabled in `chrome://flags`.
   #
@@ -17,25 +17,27 @@ module Playwright
   #
   # An example of the Android automation script would be:
   #
-  # Note that since you don't need Playwright to install web browsers when testing Android, you can omit browser download
-  # via setting the following environment variable when installing Playwright:
+  # Note that since you don't need Playwright to install web browsers when testing Android, you can omit browser download via setting the following environment variable when installing Playwright:
   #
   # ```bash js
   # PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 npm i -D playwright
   # ```
   class Android < PlaywrightApi
 
-    # This methods attaches Playwright to an existing Android device. Use [`method: Android.launchServer`] to launch a new
-    # Android server instance.
+    #
+    # This methods attaches Playwright to an existing Android device.
+    # Use [`method: Android.launchServer`] to launch a new Android server instance.
     def connect(wsEndpoint, headers: nil, slowMo: nil, timeout: nil)
       raise NotImplementedError.new('connect is not implemented yet.')
     end
 
+    #
     # Returns the list of detected Android devices.
     def devices(host: nil, omitDriverInstall: nil, port: nil)
       wrap_impl(@impl.devices(host: unwrap_impl(host), omitDriverInstall: unwrap_impl(omitDriverInstall), port: unwrap_impl(port)))
     end
 
+    #
     # This setting will change the default maximum time for all the methods accepting `timeout` option.
     def set_default_timeout(timeout)
       raise NotImplementedError.new('set_default_timeout is not implemented yet.')
@@ -44,20 +46,20 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     private def event_emitter_proxy