playwright-ruby-client 1.37.1 → 1.39.0

data/lib/playwright/errors.rb

@@ -5,13 +5,13 @@ module Playwright
       if error_payload['name'] == 'TimeoutError'
         TimeoutError.new(
           message: error_payload['message'],
-          stack: error_payload['stack'].split("\n"),
+          stack: error_payload['stack'],
         )
       else
         new(
           name: error_payload['name'],
           message: error_payload['message'],
-          stack: error_payload['stack'].split("\n"),
+          stack: error_payload['stack'],
         )
       end
     end
@@ -25,6 +25,8 @@ module Playwright
       @message = message
       @stack = stack
     end
+
+    attr_reader :name, :message, :stack
   end
 
   class DriverCrashedError < StandardError
@@ -38,4 +40,13 @@ module Playwright
       super(name: 'TimeoutError', message: message, stack: stack)
     end
   end
+
+  class WebError
+    def initialize(error, page)
+      @error = error
+      @page = PlaywrightApi.wrap(page)
+    end
+
+    attr_reader :error, :page
+  end
 end

data/lib/playwright/events.rb

@@ -29,6 +29,7 @@ end
     Console: 'console',
     Dialog: 'dialog',
     Page: 'page',
+    WebError: 'weberror',
     ServiceWorker: 'serviceworker',
     Request: 'request',
     Response: 'response',

data/lib/playwright/javascript/value_parser.rb

@@ -56,6 +56,14 @@ module Playwright
           return hash['bi'].to_i
         end
 
+        if hash.key?('m')
+          return parse_hash(hash['m']).to_h
+        end
+
+        if hash.key?('se')
+          return Set.new(parse_hash(hash['se']))
+        end
+
         if hash.key?('r')
           # @see https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/RegExp
           # @see https://docs.ruby-lang.org/ja/latest/class/Regexp.html

data/lib/playwright/javascript/value_serializer.rb

@@ -56,11 +56,17 @@ module Playwright
           result = []
           value.each { |v| result << serialize_value(v) }
           { a: result, id: id }
+        when Set
+          { se: serialize_value(value.to_a) }
         when Hash
-          id = @visited.log(value)
-          result = []
-          value.each { |key, v| result << { k: key, v: serialize_value(v) } }
-          { o: result, id: id }
+          if value.any? { |k, v| !k.is_a?(String) && !k.is_a?(Symbol) } # Map
+            { m: serialize_value(value.to_a) }
+          else
+            id = @visited.log(value)
+            result = []
+            value.each { |key, v| result << { k: key, v: serialize_value(v) } }
+            { o: result, id: id }
+          end
         else
           raise ArgumentError.new("Unexpected value: #{value}")
         end

data/lib/playwright/locator_impl.rb

@@ -446,6 +446,10 @@ module Playwright
       @frame.type(@selector, text, strict: true, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout)
     end
 
+    def press_sequentially(text, delay: nil, noWaitAfter: nil, timeout: nil)
+      type(text, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
     def uncheck(
           force: nil,
           noWaitAfter: nil,

data/lib/playwright/utils.rb

@@ -61,6 +61,10 @@ module Playwright
           end
         end
 
+        if params[:acceptDownloads] || params[:acceptDownloads] == false
+          params[:acceptDownloads] = params[:acceptDownloads] ? 'accept' : 'deny'
+        end
+
         params
       end
     end

data/lib/playwright/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '1.37.1'
-  COMPATIBLE_PLAYWRIGHT_VERSION = '1.37.0'
+  VERSION = '1.39.0'
+  COMPATIBLE_PLAYWRIGHT_VERSION = '1.39.0'
 end

data/lib/playwright_api/browser.rb

@@ -4,9 +4,9 @@ module Playwright
   # A Browser is created via [`method: BrowserType.launch`]. An example of using a `Browser` to create a `Page`:
   #
   # ```python sync
-  # from playwright.sync_api import sync_playwright
+  # from playwright.sync_api import sync_playwright, Playwright
   #
-  # def run(playwright):
+  # def run(playwright: Playwright):
   #     firefox = playwright.firefox
   #     browser = firefox.launch()
   #     page = browser.new_page()

data/lib/playwright_api/browser_context.rb

@@ -131,9 +131,9 @@ module Playwright
     # An example of exposing page URL to all frames in all pages in the context:
     #
     # ```python sync
-    # from playwright.sync_api import sync_playwright
+    # from playwright.sync_api import sync_playwright, Playwright
     #
-    # def run(playwright):
+    # def run(playwright: Playwright):
     #     webkit = playwright.webkit
     #     browser = webkit.launch(headless=false)
     #     context = browser.new_context()
@@ -190,13 +190,13 @@ module Playwright
     # import hashlib
     # from playwright.sync_api import sync_playwright
     #
-    # def sha256(text):
+    # def sha256(text: str) -> str:
     #     m = hashlib.sha256()
     #     m.update(bytes(text, "utf8"))
     #     return m.hexdigest()
     #
     #
-    # def run(playwright):
+    # def run(playwright: Playwright):
     #     webkit = playwright.webkit
     #     browser = webkit.launch(headless=False)
     #     context = browser.new_context()

data/lib/playwright_api/browser_type.rb

@@ -4,9 +4,9 @@ module Playwright
   # typical example of using Playwright to drive automation:
   #
   # ```python sync
-  # from playwright.sync_api import sync_playwright
+  # from playwright.sync_api import sync_playwright, Playwright
   #
-  # def run(playwright):
+  # def run(playwright: Playwright):
   #     chromium = playwright.chromium
   #     browser = chromium.launch()
   #     page = browser.new_page()

data/lib/playwright_api/console_message.rb

@@ -52,27 +52,5 @@ module Playwright
     def type
       wrap_impl(@impl.type)
     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

data/lib/playwright_api/dialog.rb

@@ -5,13 +5,13 @@ module Playwright
   # An example of using `Dialog` class:
   #
   # ```python sync
-  # from playwright.sync_api import sync_playwright
+  # from playwright.sync_api import sync_playwright, Playwright
   #
   # def handle_dialog(dialog):
   #     print(dialog.message)
   #     dialog.dismiss()
   #
-  # def run(playwright):
+  # def run(playwright: Playwright):
   #     chromium = playwright.chromium
   #     browser = chromium.launch()
   #     page = browser.new_page()

data/lib/playwright_api/download.rb

@@ -5,14 +5,17 @@ module Playwright
   # All the downloaded files belonging to the browser context are deleted when the
   # browser context is closed.
   #
-  # Download event is emitted once the download starts. Download path becomes available once download completes:
+  # Download event is emitted once the download starts. Download path becomes available once download completes.
   #
   # ```python sync
+  # # Start waiting for the download
   # with page.expect_download() as download_info:
+  #     # Perform the action that initiates download
   #     page.get_by_text("Download file").click()
   # download = download_info.value
-  # # wait for download to complete
-  # path = download.path()
+  #
+  # # Wait for the download process to complete and save the downloaded file somewhere
+  # download.save_as("/path/to/save/at/" + download.suggested_filename)
   # ```
   class Download < PlaywrightApi
 
@@ -54,6 +57,12 @@ module Playwright
     #
     # Copy the download to a user-specified path. It is safe to call this method while the download
     # is still in progress. Will wait for the download to finish if necessary.
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # download.save_as("/path/to/save/at/" + download.suggested_filename)
+    # ```
     def save_as(path)
       wrap_impl(@impl.save_as(unwrap_impl(path)))
     end

data/lib/playwright_api/element_handle.rb

@@ -224,7 +224,7 @@ module Playwright
     #
     # If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled instead.
     #
-    # To send fine-grained keyboard events, use [`method: ElementHandle.type`].
+    # To send fine-grained keyboard events, use [`method: Locator.pressSequentially`].
     def fill(value, force: nil, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.fill(unwrap_impl(value), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
@@ -407,7 +407,7 @@ module Playwright
     # **Usage**
     #
     # ```python sync
-    # # single selection matching the value
+    # # Single selection matching the value or label
     # handle.select_option("blue")
     # # single selection matching both the label
     # handle.select_option(label="blue")
@@ -503,19 +503,6 @@ module Playwright
     # To press a special key, like `Control` or `ArrowDown`, use [`method: ElementHandle.press`].
     #
     # **Usage**
-    #
-    # ```python sync
-    # element_handle.type("hello") # types instantly
-    # element_handle.type("world", delay=100) # types slower, like a user
-    # ```
-    #
-    # An example of typing into a text field and then submitting the form:
-    #
-    # ```python sync
-    # element_handle = page.query_selector("input")
-    # element_handle.type("some text")
-    # element_handle.press("Enter")
-    # ```
     def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.type(unwrap_impl(text), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end

data/lib/playwright_api/frame.rb

@@ -11,9 +11,9 @@ module Playwright
   # An example of dumping frame tree:
   #
   # ```python sync
-  # from playwright.sync_api import sync_playwright
+  # from playwright.sync_api import sync_playwright, Playwright
   #
-  # def run(playwright):
+  # def run(playwright: Playwright):
   #     firefox = playwright.firefox
   #     browser = firefox.launch()
   #     page = browser.new_page()
@@ -300,7 +300,7 @@ module Playwright
     #
     # If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled instead.
     #
-    # To send fine-grained keyboard events, use [`method: Frame.type`].
+    # To send fine-grained keyboard events, use [`method: Locator.pressSequentially`].
     def fill(
           selector,
           value,
@@ -757,7 +757,7 @@ module Playwright
     # **Usage**
     #
     # ```python sync
-    # # single selection matching the value
+    # # Single selection matching the value or label
     # frame.select_option("select#colors", "blue")
     # # single selection matching both the label
     # frame.select_option("select#colors", label="blue")
@@ -867,11 +867,6 @@ module Playwright
     # To press a special key, like `Control` or `ArrowDown`, use [`method: Keyboard.press`].
     #
     # **Usage**
-    #
-    # ```python sync
-    # frame.type("#mytextarea", "hello") # types instantly
-    # frame.type("#mytextarea", "world", delay=100) # types slower, like a user
-    # ```
     def type(
           selector,
           text,
@@ -919,9 +914,9 @@ module Playwright
     # The [`method: Frame.waitForFunction`] can be used to observe viewport size change:
     #
     # ```python sync
-    # from playwright.sync_api import sync_playwright
+    # from playwright.sync_api import sync_playwright, Playwright
     #
-    # def run(playwright):
+    # def run(playwright: Playwright):
     #     webkit = playwright.webkit
     #     browser = webkit.launch()
     #     page = browser.new_page()
@@ -998,9 +993,9 @@ module Playwright
     # This method works across navigations:
     #
     # ```python sync
-    # from playwright.sync_api import sync_playwright
+    # from playwright.sync_api import sync_playwright, Playwright
     #
-    # def run(playwright):
+    # def run(playwright: Playwright):
     #     chromium = playwright.chromium
     #     browser = chromium.launch()
     #     page = browser.new_page()

data/lib/playwright_api/keyboard.rb

@@ -81,6 +81,8 @@ module Playwright
       wrap_impl(@impl.insert_text(unwrap_impl(text)))
     end
 
+    #
+    # **NOTE**: In most cases, you should use [`method: Locator.press`] instead.
     #
     # `key` can specify the intended
     # [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) value or a single character to
@@ -119,6 +121,8 @@ module Playwright
       wrap_impl(@impl.press(unwrap_impl(key), delay: unwrap_impl(delay)))
     end
 
+    #
+    # **NOTE**: In most cases, you should use [`method: Locator.fill`] instead. You only need to press keys one by one if there is special keyboard handling on the page - in this case use [`method: Locator.pressSequentially`].
     #
     # Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
     #

data/lib/playwright_api/locator.rb

@@ -28,6 +28,8 @@ module Playwright
     #
     # Returns an array of `node.innerText` values for all matching nodes.
     #
+    # **NOTE**: If you need to assert text on the page, prefer [`method: LocatorAssertions.toHaveText`] with `useInnerText` option to avoid flakiness. See [assertions guide](../test-assertions.md) for more details.
+    #
     # **Usage**
     #
     # ```python sync
@@ -40,6 +42,8 @@ module Playwright
     #
     # Returns an array of `node.textContent` values for all matching nodes.
     #
+    # **NOTE**: If you need to assert text on the page, prefer [`method: LocatorAssertions.toHaveText`] to avoid flakiness. See [assertions guide](../test-assertions.md) for more details.
+    #
     # **Usage**
     #
     # ```python sync
@@ -192,6 +196,8 @@ module Playwright
     #
     # Returns the number of elements matching the locator.
     #
+    # **NOTE**: If you need to assert the number of elements on the page, prefer [`method: LocatorAssertions.toHaveCount`] to avoid flakiness. See [assertions guide](../test-assertions.md) for more details.
+    #
     # **Usage**
     #
     # ```python sync
@@ -391,7 +397,7 @@ module Playwright
     #
     # If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error. However, if the element is inside the `<label>` element that has an associated [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled instead.
     #
-    # To send fine-grained keyboard events, use [`method: Locator.type`].
+    # To send fine-grained keyboard events, use [`method: Locator.pressSequentially`].
     def fill(value, force: nil, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.fill(unwrap_impl(value), force: unwrap_impl(force), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
@@ -441,6 +447,8 @@ module Playwright
 
     #
     # Returns the matching element's attribute value.
+    #
+    # **NOTE**: If you need to assert an element's attribute, prefer [`method: LocatorAssertions.toHaveAttribute`] to avoid flakiness. See [assertions guide](../test-assertions.md) for more details.
     def get_attribute(name, timeout: nil)
       wrap_impl(@impl.get_attribute(unwrap_impl(name), timeout: unwrap_impl(timeout)))
     end
@@ -681,6 +689,8 @@ module Playwright
 
     #
     # Returns the [`element.innerText`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/innerText).
+    #
+    # **NOTE**: If you need to assert text on the page, prefer [`method: LocatorAssertions.toHaveText`] with `useInnerText` option to avoid flakiness. See [assertions guide](../test-assertions.md) for more details.
     def inner_text(timeout: nil)
       wrap_impl(@impl.inner_text(timeout: unwrap_impl(timeout)))
     end
@@ -688,6 +698,8 @@ module Playwright
     #
     # Returns the value for the matching `<input>` or `<textarea>` or `<select>` element.
     #
+    # **NOTE**: If you need to assert input value, prefer [`method: LocatorAssertions.toHaveValue`] to avoid flakiness. See [assertions guide](../test-assertions.md) for more details.
+    #
     # **Usage**
     #
     # ```python sync
@@ -704,6 +716,8 @@ module Playwright
     #
     # Returns whether the element is checked. Throws if the element is not a checkbox or radio input.
     #
+    # **NOTE**: If you need to assert that checkbox is checked, prefer [`method: LocatorAssertions.toBeChecked`] to avoid flakiness. See [assertions guide](../test-assertions.md) for more details.
+    #
     # **Usage**
     #
     # ```python sync
@@ -716,6 +730,8 @@ module Playwright
     #
     # Returns whether the element is disabled, the opposite of [enabled](../actionability.md#enabled).
     #
+    # **NOTE**: If you need to assert that an element is disabled, prefer [`method: LocatorAssertions.toBeDisabled`] to avoid flakiness. See [assertions guide](../test-assertions.md) for more details.
+    #
     # **Usage**
     #
     # ```python sync
@@ -728,6 +744,8 @@ module Playwright
     #
     # Returns whether the element is [editable](../actionability.md#editable).
     #
+    # **NOTE**: If you need to assert that an element is editable, prefer [`method: LocatorAssertions.toBeEditable`] to avoid flakiness. See [assertions guide](../test-assertions.md) for more details.
+    #
     # **Usage**
     #
     # ```python sync
@@ -740,6 +758,8 @@ module Playwright
     #
     # Returns whether the element is [enabled](../actionability.md#enabled).
     #
+    # **NOTE**: If you need to assert that an element is enabled, prefer [`method: LocatorAssertions.toBeEnabled`] to avoid flakiness. See [assertions guide](../test-assertions.md) for more details.
+    #
     # **Usage**
     #
     # ```python sync
@@ -752,6 +772,8 @@ module Playwright
     #
     # Returns whether the element is hidden, the opposite of [visible](../actionability.md#visible).
     #
+    # **NOTE**: If you need to assert that element is hidden, prefer [`method: LocatorAssertions.toBeHidden`] to avoid flakiness. See [assertions guide](../test-assertions.md) for more details.
+    #
     # **Usage**
     #
     # ```python sync
@@ -764,6 +786,8 @@ module Playwright
     #
     # Returns whether the element is [visible](../actionability.md#visible).
     #
+    # **NOTE**: If you need to assert that element is visible, prefer [`method: LocatorAssertions.toBeVisible`] to avoid flakiness. See [assertions guide](../test-assertions.md) for more details.
+    #
     # **Usage**
     #
     # ```python sync
@@ -869,6 +893,31 @@ module Playwright
       wrap_impl(@impl.press(unwrap_impl(key), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
 
+    #
+    # **NOTE**: In most cases, you should use [`method: Locator.fill`] instead. You only need to press keys one by one if there is special keyboard handling on the page.
+    #
+    # Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
+    #
+    # To press a special key, like `Control` or `ArrowDown`, use [`method: Locator.press`].
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # locator.press_sequentially("hello") # types instantly
+    # locator.press_sequentially("world", delay=100) # types slower, like a user
+    # ```
+    #
+    # An example of typing into a text field and then submitting the form:
+    #
+    # ```python sync
+    # locator = page.get_by_label("Password")
+    # locator.press_sequentially("my password")
+    # locator.press("Enter")
+    # ```
+    def press_sequentially(text, delay: nil, noWaitAfter: nil, timeout: nil)
+      wrap_impl(@impl.press_sequentially(unwrap_impl(text), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
+    end
+
     #
     # Take a screenshot of the element matching the locator.
     #
@@ -1062,31 +1111,18 @@ module Playwright
 
     #
     # Returns the [`node.textContent`](https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent).
+    #
+    # **NOTE**: If you need to assert text on the page, prefer [`method: LocatorAssertions.toHaveText`] to avoid flakiness. See [assertions guide](../test-assertions.md) for more details.
     def text_content(timeout: nil)
       wrap_impl(@impl.text_content(timeout: unwrap_impl(timeout)))
     end
 
-    #
-    # **NOTE**: In most cases, you should use [`method: Locator.fill`] instead. You only need to type characters if there is special keyboard handling on the page.
     #
     # Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
     #
     # To press a special key, like `Control` or `ArrowDown`, use [`method: Locator.press`].
     #
     # **Usage**
-    #
-    # ```python sync
-    # element.type("hello") # types instantly
-    # element.type("world", delay=100) # types slower, like a user
-    # ```
-    #
-    # An example of typing into a text field and then submitting the form:
-    #
-    # ```python sync
-    # element = page.get_by_label("Password")
-    # element.type("my password")
-    # element.press("Enter")
-    # ```
     def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.type(unwrap_impl(text), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end