playwright-ruby-client 1.28.0 → 1.29.0

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/android.rb

@@ -4,8 +4,8 @@ module Playwright
       @timeout_settings = TimeoutSettings.new
     end
 
-    def devices(port: nil)
-      params = { port: port }.compact
+    def devices(host: nil, omitDriverInstall: nil, port: nil)
+      params = { host: host, port: port, omitDriverInstall: omitDriverInstall }.compact
       resp = @channel.send_message_to_server('devices', params)
       resp.map { |device| ChannelOwners::AndroidDevice.from(device) }
     end

data/lib/playwright/channel_owners/android_device.rb

@@ -4,6 +4,11 @@ module Playwright
 
     private def after_initialize
       @input = AndroidInputImpl.new(@channel)
+      @should_close_connection_on_close = false
+    end
+
+    def should_close_connection_on_close!
+      @should_close_connection_on_close = true
     end
 
     attr_reader :input
@@ -77,8 +82,12 @@ module Playwright
     end
 
     def close
-      @channel.send_message_to_server('close')
       emit(Events::AndroidDevice::Close)
+      if @should_close_connection_on_close
+        @connection.stop
+      else
+        @channel.send_message_to_server('close')
+      end
     end
 
     def shell(command)
@@ -86,60 +95,10 @@ module Playwright
       Base64.strict_decode64(resp)
     end
 
-    def launch_browser(
-          pkg: nil,
-          acceptDownloads: nil,
-          bypassCSP: nil,
-          colorScheme: nil,
-          deviceScaleFactor: nil,
-          extraHTTPHeaders: nil,
-          geolocation: nil,
-          hasTouch: nil,
-          httpCredentials: nil,
-          ignoreHTTPSErrors: nil,
-          isMobile: nil,
-          javaScriptEnabled: nil,
-          locale: nil,
-          noViewport: nil,
-          offline: nil,
-          permissions: nil,
-          proxy: nil,
-          record_har_omit_content: nil,
-          record_har_path: nil,
-          record_video_dir: nil,
-          record_video_size: nil,
-          storageState: nil,
-          timezoneId: nil,
-          userAgent: nil,
-          viewport: nil,
-          &block)
-      params = {
-        pkg: pkg,
-        acceptDownloads: acceptDownloads,
-        bypassCSP: bypassCSP,
-        colorScheme: colorScheme,
-        deviceScaleFactor: deviceScaleFactor,
-        extraHTTPHeaders: extraHTTPHeaders,
-        geolocation: geolocation,
-        hasTouch: hasTouch,
-        httpCredentials: httpCredentials,
-        ignoreHTTPSErrors: ignoreHTTPSErrors,
-        isMobile: isMobile,
-        javaScriptEnabled: javaScriptEnabled,
-        locale: locale,
-        noViewport: noViewport,
-        offline: offline,
-        permissions: permissions,
-        proxy: proxy,
-        record_har_omit_content: record_har_omit_content,
-        record_har_path: record_har_path,
-        record_video_dir: record_video_dir,
-        record_video_size: record_video_size,
-        storageState: storageState,
-        timezoneId: timezoneId,
-        userAgent: userAgent,
-        viewport: viewport,
-      }.compact
+    def launch_browser(pkg: nil, **options, &block)
+      params = options.dup
+      params[:pkg] = pkg
+      params.compact!
       prepare_browser_context_options(params)
 
       resp = @channel.send_message_to_server('launchBrowser', params)

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/playwright.rb

@@ -39,6 +39,13 @@ module Playwright
       ::Playwright::ChannelOwners::Browser.from(@initializer['preLaunchedBrowser'])
     end
 
+    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
+
     private def parse_device_descriptor(descriptor)
       # This return value can be passed into Browser#new_context as it is.
       # ex:

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/input_files.rb

@@ -4,7 +4,9 @@ module Playwright
   class InputFiles
     def initialize(context, files)
       @context = context
-      if files.is_a?(Enumerable)
+      if files.is_a?(File)
+        @files = [files]
+      elsif files.is_a?(Enumerable)
         @files = files
       else
         @files = [files]

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.0'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.28.1'
+  VERSION = '1.29.0'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.29.1'
 end

data/lib/playwright/web_socket_transport.rb

@@ -49,7 +49,7 @@ module Playwright
       end
 
       # Wait for closed actually.
-      future.value!
+      future.value!(2)
     end
 
     # Start `playwright-cli run-driver`

data/lib/playwright.rb

@@ -51,6 +51,22 @@ module Playwright
     attr_reader :playwright, :browser
   end
 
+  class AndroidExecution
+    def initialize(connection, playwright, device = nil)
+      @connection = connection
+      @playwright = playwright
+      @device = device
+    end
+
+    def stop
+      @device&.close
+      @connection.stop
+    end
+
+    attr_reader :playwright, :device
+  end
+
+
   # Recommended to call this method with block.
   #
   # Playwright.create(...) do |playwright|
@@ -161,4 +177,43 @@ module Playwright
       execution
     end
   end
+
+    # Connects to Playwright server, launched by `npx playwright launch-server chromium` or `playwright.chromium.launchServer()`
+  #
+  # Playwright.connect_to_browser_server('ws://....') do |browser|
+  #   page = browser.new_page
+  #   ...
+  # end
+  #
+  # @experimental
+  module_function def connect_to_android_server(ws_endpoint, &block)
+    require 'playwright/web_socket_client'
+    require 'playwright/web_socket_transport'
+
+    transport = WebSocketTransport.new(ws_endpoint: ws_endpoint)
+    connection = Connection.new(transport)
+    connection.mark_as_remote
+    connection.async_run
+
+    execution =
+      begin
+        playwright = connection.initialize_playwright
+        android_device = playwright.send(:pre_connected_android_device)
+        android_device.should_close_connection_on_close!
+        AndroidExecution.new(connection, PlaywrightApi.wrap(playwright), PlaywrightApi.wrap(android_device))
+      rescue
+        connection.stop
+        raise
+      end
+
+    if block
+      begin
+        block.call(execution.device)
+      ensure
+        execution.stop
+      end
+    else
+      execution
+    end
+  end
 end