playwright-ruby-client 1.37.1 → 1.39.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00d50bbadac84d3bfa4881ee450991e7e0999c9ca5daab2343bceb885d90522b
-  data.tar.gz: 16bfdd05cc45587c02a89a9e9098c32a518c3e6b81e254524393e71b47483391
+  metadata.gz: a0dedf5c9cce96afd64ad16c45baed1b2c1fe37bb9b2632a741d8b75640bf2ae
+  data.tar.gz: 5f056dc5acd7bd5860c3ccaee1d7e5460923e9eb2a985c41ec1e36c8d8c91b7a
 SHA512:
-  metadata.gz: 4e936a99c032fb86e7865cc8880c6679a23b2d621624a98b31d528a7c9d9886851b02b6cb9bab43937bf85b85a2d27ee2cbb0d15d25a11f2962066991531eac0
-  data.tar.gz: 5e3c6c5bf4af0df7129d6c5ed1ebd6b29928ed68b10b698eb3385ac414c3a04a7ec4a96b964feffa6a65e2f96a7821c3dea8e5b841d186312a66ec1ad53ad825
+  metadata.gz: 82629797b234ab08abe2c9258605d0d7826eeaf3f4f70274e3f1ced8a5b41560ee1832f7ae98522ce7dfe1a826bd5058c88e9aba7f6d507d16bfa20d20206cea
+  data.tar.gz: '0027783e79287ba14021438154229a4de61c041c983a9f6fa582d533524df395bfb9cfaedbabf9e3d6be015a2ebed9a1fa03674bd86965f693bbd12bae9c67ce'

data/README.md

@@ -51,18 +51,24 @@ Playwright.create(playwright_cli_executable_path: './node_modules/.bin/playwrigh
     page = browser.new_page
     page.goto('https://github.com/')
 
-    form = page.query_selector("form.js-site-search-form")
-    search_input = form.query_selector("input.header-search-input")
-    search_input.click
+    page.get_by_placeholder("Search or jump to...").click
+    page.locator('input[name="query-builder-test"]').click
+
+    expect(page.keyboard).to be_a(::Playwright::Keyboard)
+
     page.keyboard.type("playwright")
     page.expect_navigation {
       page.keyboard.press("Enter")
     }
 
-    list = page.query_selector("ul.repo-list")
-    items = list.query_selector_all("div.f4")
-    items.each do |item|
-      title = item.eval_on_selector("a", "a => a.innerText")
+    list = page.get_by_test_id('results-list').locator('.search-title')
+
+    # wait for item to appear
+    list.first.wait_for
+
+    # list them
+    list.locator('.search-title').all.each do |item|
+      title = item.text_content
       puts("==> #{title}")
     end
   end

data/documentation/docs/api/browser.md

@@ -8,15 +8,19 @@ sidebar_position: 10
 
 A Browser is created via [BrowserType#launch](./browser_type#launch). An example of using a [Browser](./browser) to create a [Page](./page):
 
-```ruby
-firefox = playwright.firefox
-browser = firefox.launch
-begin
-  page = browser.new_page
-  page.goto("https://example.com")
-ensure
-  browser.close
-end
+```python sync title=example_5d31815545511b1d8ce5dfce5b153cb5ea46a1868cee95eb211d77f33026788b.py
+from playwright.sync_api import sync_playwright, Playwright
+
+def run(playwright: Playwright):
+    firefox = playwright.firefox
+    browser = firefox.launch()
+    page = browser.new_page()
+    page.goto("https://example.com")
+    browser.close()
+
+with sync_playwright() as playwright:
+    run(playwright)
+
 ```
 
 ## browser_type

data/documentation/docs/api/browser_context.md

@@ -158,21 +158,29 @@ See [Page#expose_binding](./page#expose_binding) for page-only version.
 
 An example of exposing page URL to all frames in all pages in the context:
 
-```ruby
-browser_context.expose_binding("pageURL", ->(source) { source[:page].url })
-page = browser_context.new_page
-
-page.content = <<~HTML
-<script>
-  async function onClick() {
-    document.querySelector('div').textContent = await window.pageURL();
-  }
-</script>
-<button onclick="onClick()">Click me</button>
-<div></div>
-HTML
+```python sync title=example_a450852d36dda88564582371af8d87bb58b1a517aac4fa60b7a58a0e41c5ceff.py
+from playwright.sync_api import sync_playwright, Playwright
+
+def run(playwright: Playwright):
+    webkit = playwright.webkit
+    browser = webkit.launch(headless=false)
+    context = browser.new_context()
+    context.expose_binding("pageURL", lambda source: source["page"].url)
+    page = context.new_page()
+    page.set_content("""
+    <script>
+      async function onClick() {
+        document.querySelector('div').textContent = await window.pageURL();
+      }
+    </script>
+    <button onclick="onClick()">Click me</button>
+    <div></div>
+    """)
+    page.get_by_role("button").click()
+
+with sync_playwright() as playwright:
+    run(playwright)
 
-page.get_by_role("button").click
 ```
 
 An example of passing an element handle:
@@ -217,25 +225,36 @@ See [Page#expose_function](./page#expose_function) for page-only version.
 
 An example of adding a `sha256` function to all pages in the context:
 
-```ruby
-require 'digest'
-
-def sha256(text)
-  Digest::SHA256.hexdigest(text)
-end
+```python sync title=example_714719de9c92e66678257180301c2512f8cd69185f53a5121b6c52194f61a871.py
+import hashlib
+from playwright.sync_api import sync_playwright
+
+def sha256(text: str) -> str:
+    m = hashlib.sha256()
+    m.update(bytes(text, "utf8"))
+    return m.hexdigest()
+
+
+def run(playwright: Playwright):
+    webkit = playwright.webkit
+    browser = webkit.launch(headless=False)
+    context = browser.new_context()
+    context.expose_function("sha256", sha256)
+    page = context.new_page()
+    page.set_content("""
+        <script>
+          async function onClick() {
+            document.querySelector('div').textContent = await window.sha256('PLAYWRIGHT');
+          }
+        </script>
+        <button onclick="onClick()">Click me</button>
+        <div></div>
+    """)
+    page.get_by_role("button").click()
+
+with sync_playwright() as playwright:
+    run(playwright)
 
-browser_context.expose_function("sha256", method(:sha256))
-page = browser_context.new_page()
-page.content = <<~HTML
-<script>
-  async function onClick() {
-    document.querySelector('div').textContent = await window.sha256('PLAYWRIGHT');
-  }
-</script>
-<button onclick="onClick()">Click me</button>
-<div></div>
-HTML
-page.get_by_role("button").click
 ```
 
 ## grant_permissions

data/documentation/docs/api/browser_type.md

@@ -8,15 +8,20 @@ sidebar_position: 10
 BrowserType provides methods to launch a specific browser instance or connect to an existing one. The following is a
 typical example of using Playwright to drive automation:
 
-```ruby
-chromium = playwright.chromium
-chromium.launch do |browser|
-  page = browser.new_page
-  page.goto('https://example.com/')
+```python sync title=example_2f9fbff87f35af4b76a27f54efeca3201696bbfa94ce03fee5a3df2639cc27d3.py
+from playwright.sync_api import sync_playwright, Playwright
+
+def run(playwright: Playwright):
+    chromium = playwright.chromium
+    browser = chromium.launch()
+    page = browser.new_page()
+    page.goto("https://example.com")
+    # other actions...
+    browser.close()
 
-  # other actions
+with sync_playwright() as playwright:
+    run(playwright)
 
-end
 ```
 
 ## connect_over_cdp

data/documentation/docs/api/dialog.md

@@ -9,21 +9,24 @@ sidebar_position: 10
 
 An example of using [Dialog](./dialog) class:
 
-```ruby
-def handle_dialog(dialog)
-  puts "[#{dialog.type}] #{dialog.message}"
-  if dialog.message =~ /foo/
-    dialog.accept
-  else
-    dialog.dismiss
-  end
-end
-
-page.on("dialog", method(:handle_dialog))
-page.evaluate("confirm('foo')") # will be accepted
-# => [confirm] foo
-page.evaluate("alert('bar')") # will be dismissed
-# => [alert] bar
+```python sync title=example_a7dcc75b7aa5544237ac3a964e9196d0445308864d3ce820f8cb8396f687b04a.py
+from playwright.sync_api import sync_playwright, Playwright
+
+def handle_dialog(dialog):
+    print(dialog.message)
+    dialog.dismiss()
+
+def run(playwright: Playwright):
+    chromium = playwright.chromium
+    browser = chromium.launch()
+    page = browser.new_page()
+    page.on("dialog", handle_dialog)
+    page.evaluate("alert('1')")
+    browser.close()
+
+with sync_playwright() as playwright:
+    run(playwright)
+
 ```
 
 **NOTE**: Dialogs are dismissed automatically, unless there is a [`event: Page.dialog`] listener.

data/documentation/docs/api/download.md

@@ -10,15 +10,18 @@ sidebar_position: 10
 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.
 
-```ruby
-download = page.expect_download do
-  page.get_by_text("Download file").click
-end
+```python sync title=example_c247767083cf193df26a39a61a3a8bc19d63ed5c24db91b88c50b7d37975005d.py
+# 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 the download process to complete and save the downloaded file somewhere
+download.save_as("/path/to/save/at/" + download.suggested_filename)
 
-# wait for download to complete
-path = download.path
 ```
 
 ## cancel
@@ -81,6 +84,13 @@ def save_as(path)
 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 title=example_66ffd4ef7286957e4294d84b8f660ff852c87af27a56b3e4dd9f84562b5ece02.py
+download.save_as("/path/to/save/at/" + download.suggested_filename)
+
+```
+
 ## suggested_filename
 
 ```

data/documentation/docs/api/element_handle.md

@@ -259,7 +259,7 @@ This method waits for [actionability](https://playwright.dev/python/docs/actiona
 
 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 [ElementHandle#type](./element_handle#type).
+To send fine-grained keyboard events, use [Locator#press_sequentially](./locator#press_sequentially).
 
 ## focus
 
@@ -505,13 +505,14 @@ Triggers a `change` and `input` event once all the provided options have been se
 
 **Usage**
 
-```ruby
-# single selection matching the value
-element_handle.select_option(value: "blue")
+```python sync title=example_e6bbc99e34c9f6ee73aa7d4265d34af456e6c67d185530f0a77f8064050a3ec4.py
+# Single selection matching the value or label
+handle.select_option("blue")
 # single selection matching both the label
-element_handle.select_option(label: "blue")
+handle.select_option(label="blue")
 # multiple selection
-element_handle.select_option(value: ["red", "green", "blue"])
+handle.select_option(value=["red", "green", "blue"])
+
 ```
 
 ## select_text
@@ -614,19 +615,6 @@ To press a special key, like `Control` or `ArrowDown`, use [ElementHandle#press]
 
 **Usage**
 
-```ruby
-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:
-
-```ruby
-element_handle = page.query_selector("input")
-element_handle.type("some text")
-element_handle.press("Enter")
-```
-
 ## uncheck
 
 ```

data/documentation/docs/api/frame.md

@@ -15,16 +15,25 @@ At every point of time, page exposes its current frame tree via the [Page#main_f
 
 An example of dumping frame tree:
 
-```ruby
-def dump_frame_tree(frame, indent = 0)
-  puts "#{' ' * indent}#{frame.name}@#{frame.url}"
-  frame.child_frames.each do |child|
-    dump_frame_tree(child, indent + 2)
-  end
-end
+```python sync title=example_2bc8a0187190738d8dc7b29c66ad5f9f2187fd1827455e9ceb1e9ace26aaf534.py
+from playwright.sync_api import sync_playwright, Playwright
+
+def run(playwright: Playwright):
+    firefox = playwright.firefox
+    browser = firefox.launch()
+    page = browser.new_page()
+    page.goto("https://www.theverge.com")
+    dump_frame_tree(page.main_frame, "")
+    browser.close()
+
+def dump_frame_tree(frame, indent):
+    print(indent + frame.name + '@' + frame.url)
+    for child in frame.child_frames:
+        dump_frame_tree(child, indent + "    ")
+
+with sync_playwright() as playwright:
+    run(playwright)
 
-page.goto("https://www.theverge.com")
-dump_frame_tree(page.main_frame)
 ```
 
 ## add_script_tag
@@ -349,7 +358,7 @@ This method waits for an element matching `selector`, waits for [actionability](
 
 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 [Frame#type](./frame#type).
+To send fine-grained keyboard events, use [Locator#press_sequentially](./locator#press_sequentially).
 
 ## focus
 
@@ -911,13 +920,14 @@ Triggers a `change` and `input` event once all the provided options have been se
 
 **Usage**
 
-```ruby
-# single selection matching the value
-frame.select_option("select#colors", value: "blue")
+```python sync title=example_3f390f340c78c42dd0c88a09b2f56575b02b163786e8cdee33581217afced6b2.py
+# 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")
+frame.select_option("select#colors", label="blue")
 # multiple selection
-frame.select_option("select#colors", value: ["red", "green", "blue"])
+frame.select_option("select#colors", value=["red", "green", "blue"])
+
 ```
 
 ## set_checked
@@ -1041,11 +1051,6 @@ To press a special key, like `Control` or `ArrowDown`, use [Keyboard#press](./ke
 
 **Usage**
 
-```ruby
-frame.type("#mytextarea", "hello") # types instantly
-frame.type("#mytextarea", "world", delay: 100) # types slower, like a user
-```
-
 ## uncheck
 
 ```
@@ -1094,9 +1099,20 @@ Returns when the `expression` returns a truthy value, returns that value.
 
 The [Frame#wait_for_function](./frame#wait_for_function) can be used to observe viewport size change:
 
-```ruby
-frame.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);")
-frame.wait_for_function("() => window.x > 0")
+```python sync title=example_e6a8c279eb09e58e3522cb6237f5d62165b164cad0c1916720af299ffcb8dc8a.py
+from playwright.sync_api import sync_playwright, Playwright
+
+def run(playwright: Playwright):
+    webkit = playwright.webkit
+    browser = webkit.launch()
+    page = browser.new_page()
+    page.evaluate("window.x = 0; setTimeout(() => { window.x = 100 }, 1000);")
+    page.main_frame.wait_for_function("() => window.x > 0")
+    browser.close()
+
+with sync_playwright() as playwright:
+    run(playwright)
+
 ```
 
 To pass an argument to the predicate of `frame.waitForFunction` function:
@@ -1172,13 +1188,22 @@ function will throw.
 
 This method works across navigations:
 
-```ruby
-%w[https://google.com https://bbc.com].each do |current_url|
-  page.goto(current_url, waitUntil: "domcontentloaded")
-  frame = page.main_frame
-  element = frame.wait_for_selector("img")
-  puts "Loaded image: #{element["src"]}"
-end
+```python sync title=example_6e2a71807566cf008382d4c163ff6e71e34d7f10ef6706ad7fcaa9b70c256a66.py
+from playwright.sync_api import sync_playwright, Playwright
+
+def run(playwright: Playwright):
+    chromium = playwright.chromium
+    browser = chromium.launch()
+    page = browser.new_page()
+    for current_url in ["https://google.com", "https://bbc.com"]:
+        page.goto(current_url, wait_until="domcontentloaded")
+        element = page.main_frame.wait_for_selector("img")
+        print("Loaded image: " + str(element.get_attribute("src")))
+    browser.close()
+
+with sync_playwright() as playwright:
+    run(playwright)
+
 ```
 
 ## wait_for_timeout

data/documentation/docs/api/keyboard.md

@@ -97,6 +97,8 @@ def press(key, delay: nil)
 ```
 
 
+**NOTE**: In most cases, you should use [Locator#press](./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
 generate the text for. A superset of the `key` values can be found
@@ -136,6 +138,8 @@ def type(text, delay: nil)
 ```
 
 
+**NOTE**: In most cases, you should use [Locator#fill](./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 [Locator#press_sequentially](./locator#press_sequentially).
+
 Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
 
 To press a special key, like `Control` or `ArrowDown`, use [Keyboard#press](./keyboard#press).

data/documentation/docs/api/locator.md

@@ -42,6 +42,8 @@ def all_inner_texts
 
 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](https://playwright.dev/python/docs/test-assertions) for more details.
+
 **Usage**
 
 ```ruby
@@ -57,6 +59,8 @@ def all_text_contents
 
 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](https://playwright.dev/python/docs/test-assertions) for more details.
+
 **Usage**
 
 ```ruby
@@ -232,6 +236,8 @@ def count
 
 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](https://playwright.dev/python/docs/test-assertions) for more details.
+
 **Usage**
 
 ```ruby
@@ -458,7 +464,7 @@ This method waits for [actionability](https://playwright.dev/python/docs/actiona
 
 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 [Locator#type](./locator#type).
+To send fine-grained keyboard events, use [Locator#press_sequentially](./locator#press_sequentially).
 
 ## filter
 
@@ -526,6 +532,8 @@ alias: `[]`
 
 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](https://playwright.dev/python/docs/test-assertions) for more details.
+
 ## get_by_alt_text
 
 ```
@@ -808,6 +816,8 @@ def inner_text(timeout: nil)
 
 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](https://playwright.dev/python/docs/test-assertions) for more details.
+
 ## input_value
 
 ```
@@ -817,6 +827,8 @@ def input_value(timeout: nil)
 
 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](https://playwright.dev/python/docs/test-assertions) for more details.
+
 **Usage**
 
 ```ruby
@@ -836,6 +848,8 @@ def checked?(timeout: nil)
 
 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](https://playwright.dev/python/docs/test-assertions) for more details.
+
 **Usage**
 
 ```ruby
@@ -851,6 +865,8 @@ def disabled?(timeout: nil)
 
 Returns whether the element is disabled, the opposite of [enabled](https://playwright.dev/python/docs/actionability#enabled).
 
+**NOTE**: If you need to assert that an element is disabled, prefer [`method: LocatorAssertions.toBeDisabled`] to avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
 **Usage**
 
 ```ruby
@@ -866,6 +882,8 @@ def editable?(timeout: nil)
 
 Returns whether the element is [editable](https://playwright.dev/python/docs/actionability#editable).
 
+**NOTE**: If you need to assert that an element is editable, prefer [`method: LocatorAssertions.toBeEditable`] to avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
 **Usage**
 
 ```ruby
@@ -881,6 +899,8 @@ def enabled?(timeout: nil)
 
 Returns whether the element is [enabled](https://playwright.dev/python/docs/actionability#enabled).
 
+**NOTE**: If you need to assert that an element is enabled, prefer [`method: LocatorAssertions.toBeEnabled`] to avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
 **Usage**
 
 ```ruby
@@ -896,6 +916,8 @@ def hidden?(timeout: nil)
 
 Returns whether the element is hidden, the opposite of [visible](https://playwright.dev/python/docs/actionability#visible).
 
+**NOTE**: If you need to assert that element is hidden, prefer [`method: LocatorAssertions.toBeHidden`] to avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
 **Usage**
 
 ```ruby
@@ -911,6 +933,8 @@ def visible?(timeout: nil)
 
 Returns whether the element is [visible](https://playwright.dev/python/docs/actionability#visible).
 
+**NOTE**: If you need to assert that element is visible, prefer [`method: LocatorAssertions.toBeVisible`] to avoid flakiness. See [assertions guide](https://playwright.dev/python/docs/test-assertions) for more details.
+
 **Usage**
 
 ```ruby
@@ -1032,6 +1056,36 @@ respective texts.
 Shortcuts such as `key: "Control+o"` or `key: "Control+Shift+T"` are supported as well. When specified with the
 modifier, modifier is pressed and being held while the subsequent key is being pressed.
 
+## press_sequentially
+
+```
+def press_sequentially(text, delay: nil, noWaitAfter: nil, timeout: nil)
+```
+
+
+**NOTE**: In most cases, you should use [Locator#fill](./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 [Locator#press](./locator#press).
+
+**Usage**
+
+```python sync title=example_1b7781d5527574a18d4b9812e3461203d2acc9ba7e09cbfd0ffbc4154e3f5971.py
+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 title=example_cc0a6b9aa95b97e5c17c4b114da10a29c7f6f793e99aee1ea2703636af6e24f9.py
+locator = page.get_by_label("Password")
+locator.press_sequentially("my password")
+locator.press("Enter")
+
+```
+
 ## screenshot
 
 ```
@@ -1247,6 +1301,8 @@ def text_content(timeout: nil)
 
 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](https://playwright.dev/python/docs/test-assertions) for more details.
+
 ## type
 
 ```
@@ -1254,27 +1310,12 @@ def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
 ```
 
 
-**NOTE**: In most cases, you should use [Locator#fill](./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 [Locator#press](./locator#press).
 
 **Usage**
 
-```ruby
-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:
-
-```ruby
-element = page.get_by_label("Password")
-element.type("my password")
-element.press("Enter")
-```
-
 ## uncheck
 
 ```