playwright-ruby-client 1.59.1 → 1.61.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8943d61bb3cd1ebe3737284e7556d8bcb4b1be154105c2bb05f8d8d77ba51aca
-  data.tar.gz: 15fdc15c33208bb8389306733807768797038d7a788c9f3e5f7465680823ebb7
+  metadata.gz: c45763ab237c198b8f2aa3afa3114ae0bf821481e57711516f5014547079f183
+  data.tar.gz: ed8d42f43cb28c8ae2a45755332582b6e51ac993a751de94fb1a25fff43f5532
 SHA512:
-  metadata.gz: 1787fb9a9b61c92bb3cb0adc512e18349ae2830d59914e6ac6c202361b849d20e0c09f3fef4ecfa250b90e6858ce60a381c3fe76fcb3c96fd9b42ccf548d26e0
-  data.tar.gz: b72617a5d25b592c8e3a8d54dc887a56776448be204cc7d1e901145d449b3aadca42090010978c547c8e8e1cc1f0418415624008cd60122eea3a41a4d76c1af8
+  metadata.gz: 90ac4618f354ca98c4d5a5c7284b23d752a098bf7128a246076964381f36d93680b78c89599b15b175afdb7274e6cea1882cfab64f9d9eab6dcb1317b0f0f894
+  data.tar.gz: 91cdfb64498f4e76f0f3a6f726fd49fa3d36dd7c6b692e843455bf8a9160a94216f13e324ffe90a2472c0b9ad573bd1d1ab241590629357d01562991ea299c63

data/documentation/docs/api/api_request.md

@@ -4,4 +4,28 @@ sidebar_position: 10
 
 # APIRequest
 
-Not Implemented
+
+Exposes API that can be used for the Web API testing. This class is used for creating
+[APIRequestContext](./api_request_context) instance which in turn can be used for sending web requests. An instance
+of this class can be obtained via [Playwright#request](./playwright#request). For more information
+see [APIRequestContext](./api_request_context).
+
+## new_context
+
+```
+def new_context(
+      baseURL: nil,
+      clientCertificates: nil,
+      extraHTTPHeaders: nil,
+      failOnStatusCode: nil,
+      httpCredentials: nil,
+      ignoreHTTPSErrors: nil,
+      maxRedirects: nil,
+      proxy: nil,
+      storageState: nil,
+      timeout: nil,
+      userAgent: nil)
+```
+
+
+Creates new instances of [APIRequestContext](./api_request_context).

data/documentation/docs/api/api_request_context.md

@@ -8,21 +8,21 @@ sidebar_position: 10
 This API is used for the Web API testing. You can use it to trigger API endpoints, configure micro-services, prepare
 environment or the service to your e2e test.
 
-Each Playwright browser context has associated with it [APIRequestContext](./api_request_context) instance which shares cookie storage with
-the browser context and can be accessed via [BrowserContext#request](./browser_context#request) or [Page#request](./page#request).
-It is also possible to create a new APIRequestContext instance manually by calling [APIRequest#new_context](./api_request#new_context).
+Each Playwright browser context has an associated [APIRequestContext](./api_request_context), accessible via
+[BrowserContext#request](./browser_context#request) or [Page#request](./page#request) (these return the
+
+**same instance** — `page.request` is a shortcut for `page.context().request`).
+You can also create a standalone, isolated instance with [APIRequest#new_context](./api_request#new_context).
 
 **Cookie management**
 
-[APIRequestContext](./api_request_context) returned by [BrowserContext#request](./browser_context#request) and [Page#request](./page#request) shares cookie
-storage with the corresponding [BrowserContext](./browser_context). Each API request will have `Cookie` header populated with the
-values from the browser context. If the API response contains `Set-Cookie` header it will automatically update
-[BrowserContext](./browser_context) cookies and requests made from the page will pick them up. This means that if you log in using
-this API, your e2e test will be logged in and vice versa.
+The [APIRequestContext](./api_request_context) returned by [BrowserContext#request](./browser_context#request) and
+
+[Page#request](./page#request) uses the same cookie jar as its [BrowserContext](./browser_context):
 
-If you want API requests to not interfere with the browser cookies you should create a new [APIRequestContext](./api_request_context) by
-calling [APIRequest#new_context](./api_request#new_context). Such [APIRequestContext](./api_request_context) object will have its own isolated cookie
-storage.
+If you want API requests that do **not** share cookies with the browser, create an
+isolated context via [APIRequest#new_context](./api_request#new_context). Such [APIRequestContext](./api_request_context)
+object will have its own isolated cookie storage.
 
 ```ruby
 playwright.chromium.launch do |browser|
@@ -296,3 +296,5 @@ def put(
 Sends HTTP(S) [PUT](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT) request and returns its response.
 The method will populate request cookies from the context and update
 context cookies from the response. The method will automatically follow redirects.
+
+## tracing

data/documentation/docs/api/api_response.md

@@ -77,6 +77,24 @@ def ok
 
 Contains a boolean stating whether the response was successful (status in the range 200-299) or not.
 
+## security_details
+
+```
+def security_details
+```
+
+
+Returns SSL and other security information. Resolves to `null` for non-HTTPS responses. For redirected requests, returns the information for the last request in the redirect chain.
+
+## server_addr
+
+```
+def server_addr
+```
+
+
+Returns the IP address and port of the server. Resolves to `null` if the server address is not available. For redirected requests, returns the information for the last request in the redirect chain.
+
 ## status
 
 ```

data/documentation/docs/api/browser.md

@@ -193,6 +193,15 @@ This is a convenience API that should only be used for the single-page scenarios
 testing frameworks should explicitly create [Browser#new_context](./browser#new_context) followed by the
 [BrowserContext#new_page](./browser_context#new_page) to control their exact life times.
 
+## bind
+
+```
+def bind(title, host: nil, port: nil, workspaceDir: nil)
+```
+
+
+Binds the browser to a named pipe or web socket, making it available for other clients to connect to.
+
 ## start_tracing
 
 ```
@@ -227,6 +236,15 @@ def stop_tracing
 
 Returns the buffer with trace data.
 
+## unbind
+
+```
+def unbind
+```
+
+
+Unbinds the browser server previously bound with [Browser#bind](./browser#bind).
+
 ## version
 
 ```

data/documentation/docs/api/browser_context.md

@@ -154,7 +154,7 @@ are returned.
 ## expose_binding
 
 ```
-def expose_binding(name, callback, handle: nil)
+def expose_binding(name, callback)
 ```
 
 
@@ -521,6 +521,12 @@ Will throw an error if the context closes before new [Page](./page) is created.
 
 Playwright has ability to mock clock and passage of time.
 
+## credentials
+
+
+Virtual WebAuthn authenticator for this context. Lets tests seed credentials and intercept
+`navigator.credentials.create()` / `navigator.credentials.get()` ceremonies.
+
 ## request
 
 

data/documentation/docs/api/browser_type.md

@@ -19,13 +19,32 @@ chromium.launch do |browser|
 end
 ```
 
+## connect
+
+```
+def connect(
+      endpoint,
+      exposeNetwork: nil,
+      headers: nil,
+      slowMo: nil,
+      timeout: nil,
+      &block)
+```
+
+
+This method attaches Playwright to an existing browser instance created via `BrowserType.launchServer` in Node.js.
+
+**NOTE**: The major and minor version of the Playwright instance that connects needs to match the version of Playwright that launches the browser (1.2.3 → is compatible with 1.2.x).
+
 ## connect_over_cdp
 
 ```
 def connect_over_cdp(
       endpointURL,
+      artifactsDir: nil,
       headers: nil,
       isLocal: nil,
+      noDefaults: nil,
       slowMo: nil,
       timeout: nil,
       &block)

data/documentation/docs/api/credentials.md

@@ -0,0 +1,132 @@
+---
+sidebar_position: 10
+---
+
+# Credentials
+
+
+[Credentials](./credentials) is a virtual WebAuthn authenticator scoped to a [BrowserContext](./browser_context). It lets tests
+register passkeys and answer `navigator.credentials.create()` / `navigator.credentials.get()`
+ceremonies in the page, without a real authenticator or hardware security key.
+
+There are two common ways to use it:
+
+**Usage: seed a known credential**
+
+```ruby
+context = browser.new_context
+
+# A passkey your backend already provisioned for a test user.
+context.credentials.create(
+  "example.com",
+  id: known_credential_id, # base64url
+  userHandle: known_user_handle, # base64url
+  privateKey: known_private_key, # base64url PKCS#8 (DER)
+  publicKey: known_public_key, # base64url SPKI (DER)
+)
+context.credentials.install
+
+page = context.new_page
+page.goto("https://example.com/login")
+# The page's navigator.credentials.get() is answered with the seeded passkey.
+```
+
+**Usage: capture a passkey, then reuse it**
+
+```ruby
+# setup test: let the app register a passkey, then save it.
+context = browser.new_context
+context.credentials.install
+
+page = context.new_page
+page.goto("https://example.com/register")
+page.get_by_role("button", name: "Create a passkey").click
+
+# Read back the passkey the page registered - it includes the private key.
+credential = context.credentials.get(rpId: "example.com").first
+File.write("playwright/.auth/passkey.json", JSON.generate(credential))
+```
+
+```ruby
+# later test: seed the captured passkey so the app starts already enrolled.
+credential = JSON.parse(File.read("playwright/.auth/passkey.json"))
+context = browser.new_context
+context.credentials.create(
+  credential["rpId"],
+  id: credential["id"],
+  userHandle: credential["userHandle"],
+  privateKey: credential["privateKey"],
+  publicKey: credential["publicKey"],
+)
+context.credentials.install
+
+page = context.new_page
+page.goto("https://example.com/login")
+# navigator.credentials.get() resolves the captured passkey - already signed in.
+```
+
+**Defaults**
+
+## install
+
+```
+def install
+```
+
+
+Installs the virtual WebAuthn authenticator into the context, overriding
+`navigator.credentials.create()` and `navigator.credentials.get()` in all current
+and future pages. Call this before the page first touches `navigator.credentials`.
+
+Required: until [Credentials#install](./credentials#install) is called, no interception is in place and the page sees
+the platform's native (or absent) WebAuthn behaviour. Seeding credentials with
+[Credentials#create](./credentials#create) without installing populates the authenticator, but the
+page will never see those credentials.
+
+## create
+
+```
+def create(
+      rpId,
+      id: nil,
+      privateKey: nil,
+      publicKey: nil,
+      userHandle: nil)
+```
+
+
+Seeds a virtual WebAuthn credential and returns it.
+
+With only `rpId`, generates a fresh **ECDSA P-256** keypair, credential id and user handle. The
+seeded credential is discoverable (resident), so the page can resolve it from both
+username-then-passkey and usernameless passkey flows. The returned object carries the private and public keys, so it can be persisted to disk and re-seeded in a later test.
+
+To **import a known credential**, supply all four of `id`, `userHandle`, `privateKey` and
+`publicKey` together.
+
+Call [Credentials#install](./credentials#install) before navigating to a page that uses WebAuthn.
+
+## delete
+
+```
+def delete(id)
+```
+
+
+Removes a credential from the authenticator by its id. Works for any credential currently held —
+both those seeded with [Credentials#create](./credentials#create) and those the page registered itself by
+calling `navigator.credentials.create()`.
+
+## get
+
+```
+def get(id: nil, rpId: nil)
+```
+
+
+Returns every credential currently held by the authenticator, optionally filtered by `rpId` or
+`id`. This includes both credentials seeded with [Credentials#create](./credentials#create) and credentials
+the page registered itself by calling `navigator.credentials.create()`.
+
+Each returned credential includes its private and public keys, so a passkey the app just
+registered can be saved and re-seeded into a later test with [Credentials#create](./credentials#create) — see the second example in the class overview.

data/documentation/docs/api/frame.md

@@ -291,7 +291,7 @@ puts frame.evaluate("1 + #{x}") # => "11"
 [ElementHandle](./element_handle) instances can be passed as an argument to the [Frame#evaluate](./frame#evaluate):
 
 ```ruby
-body_handle = frame.query_selector("body")
+body_handle = frame.evaluate_handle("document.body")
 html = frame.evaluate("([body, suffix]) => body.innerHTML + suffix", arg: [body_handle, "hello"])
 body_handle.dispose
 ```
@@ -321,14 +321,14 @@ a_window_handle # handle for the window object.
 A string can also be passed in instead of a function.
 
 ```ruby
-a_handle = page.evaluate_handle("document") # handle for the "document"
+a_handle = frame.evaluate_handle("document") # handle for the "document"
 ```
 
 [JSHandle](./js_handle) instances can be passed as an argument to the [Frame#evaluate_handle](./frame#evaluate_handle):
 
 ```ruby
-body_handle = page.evaluate_handle("document.body")
-result_handle = page.evaluate_handle("body => body.innerHTML", arg: body_handle)
+a_handle = frame.evaluate_handle("document.body")
+result_handle = frame.evaluate_handle("body => body.innerHTML", arg: a_handle)
 puts result_handle.json_value
 result_handle.dispose
 ```
@@ -486,6 +486,7 @@ page.get_by_placeholder("name@example.com").fill("playwright@microsoft.com")
 def get_by_role(
       role,
       checked: nil,
+      description: nil,
       disabled: nil,
       exact: nil,
       expanded: nil,

data/documentation/docs/api/frame_locator.md

@@ -131,6 +131,7 @@ page.get_by_placeholder("name@example.com").fill("playwright@microsoft.com")
 def get_by_role(
       role,
       checked: nil,
+      description: nil,
       disabled: nil,
       exact: nil,
       expanded: nil,

data/documentation/docs/api/locator.md

@@ -87,7 +87,7 @@ button = page.get_by_role("button").and(page.get_by_title("Subscribe"))
 ## aria_snapshot
 
 ```
-def aria_snapshot(depth: nil, mode: nil, timeout: nil)
+def aria_snapshot(boxes: nil, depth: nil, mode: nil, timeout: nil)
 ```
 
 
@@ -441,6 +441,31 @@ source.drag_to(
 )
 ```
 
+## drop
+
+```
+def drop(payload, position: nil, timeout: nil)
+```
+
+
+Simulate an external drag-and-drop of files or clipboard-like data onto this locator.
+
+**Details**
+
+Dispatches the native `dragenter`, `dragover`, and `drop` events at the center of the
+target element with a synthetic [DataTransfer] carrying the provided files and/or data
+entries. Works cross-browser by constructing the [DataTransfer] in the page context.
+
+If the target element's `dragover` listener does not call `preventDefault()`, the target
+is considered to have rejected the drop: Playwright dispatches `dragleave` and this
+method throws.
+
+**Usage**
+
+Drop a file buffer onto an upload area:
+
+Drop plain text and a URL together:
+
 ## element_handle
 
 ```
@@ -721,6 +746,7 @@ page.get_by_placeholder("name@example.com").fill("playwright@microsoft.com")
 def get_by_role(
       role,
       checked: nil,
+      description: nil,
       disabled: nil,
       exact: nil,
       expanded: nil,
@@ -869,10 +895,19 @@ You can check the issues count after locating it by the title text:
 page.get_by_title("Issues count").text_content # => "25 issues"
 ```
 
+## hide_highlight
+
+```
+def hide_highlight
+```
+
+
+Hides the element highlight previously added by [Locator#highlight](./locator#highlight).
+
 ## highlight
 
 ```
-def highlight
+def highlight(style: nil)
 ```
 
 

data/documentation/docs/api/locator_assertions.md

@@ -647,7 +647,7 @@ expect(locator).to have_count(3)
 ## to_have_css
 
 ```ruby
-expect(locator).to have_css(name, value, timeout: nil)
+expect(locator).to have_css(name, value, pseudo: nil, timeout: nil)
 ```
 
 

data/documentation/docs/api/page.md

@@ -413,7 +413,7 @@ puts page.evaluate("1 + #{x}") # => "11"
 [ElementHandle](./element_handle) instances can be passed as an argument to the [Page#evaluate](./page#evaluate):
 
 ```ruby
-body_handle = page.query_selector("body")
+body_handle = page.evaluate_handle("document.body")
 html = page.evaluate("([body, suffix]) => body.innerHTML + suffix", arg: [body_handle, "hello"])
 body_handle.dispose
 ```
@@ -457,7 +457,7 @@ result_handle.dispose
 ## expose_binding
 
 ```
-def expose_binding(name, callback, handle: nil)
+def expose_binding(name, callback)
 ```
 
 
@@ -690,6 +690,7 @@ page.get_by_placeholder("name@example.com").fill("playwright@microsoft.com")
 def get_by_role(
       role,
       checked: nil,
+      description: nil,
       disabled: nil,
       exact: nil,
       expanded: nil,
@@ -889,6 +890,15 @@ Found" and 500 "Internal Server Error".  The status code for such responses can
 **NOTE**: Headless mode doesn't support navigation to a PDF document. See the
 [upstream issue](https://bugs.chromium.org/p/chromium/issues/detail?id=761295).
 
+## hide_highlight
+
+```
+def hide_highlight
+```
+
+
+Hide all locator highlight overlays previously added by [Locator#highlight](./locator#highlight) on this page.
+
 ## hover
 
 ```
@@ -1521,7 +1531,7 @@ page.goto("https://example.com")
 ## aria_snapshot
 
 ```
-def aria_snapshot(depth: nil, mode: nil, timeout: nil)
+def aria_snapshot(boxes: nil, depth: nil, mode: nil, timeout: nil)
 ```
 
 
@@ -1551,7 +1561,7 @@ This method taps an element matching `selector` by performing the following step
 When all steps combined have not finished during the specified `timeout`, this method throws a
 `TimeoutError`. Passing zero timeout disables this.
 
-**NOTE**: [Page#tap_point](./page#tap_point) the method will throw if `hasTouch` option of the browser context is false.
+**NOTE**: [Page#tap_point](./page#tap_point) will throw if the `hasTouch` option of the browser context is false.
 
 ## text_content
 
@@ -1991,6 +2001,16 @@ Playwright has ability to mock clock and passage of time.
 
 ## keyboard
 
+## local_storage
+
+
+Provides access to the page's `localStorage` for the current origin. See [WebStorage](./web_storage).
+
+## session_storage
+
+
+Provides access to the page's `sessionStorage` for the current origin. See [WebStorage](./web_storage).
+
 ## mouse
 
 ## request

data/documentation/docs/api/page_assertions.md

@@ -34,6 +34,34 @@ def not_to_have_url(urlOrRegExp, ignoreCase: nil, timeout: nil)
 
 The opposite of [PageAssertions#to_have_url](./page_assertions#to_have_url).
 
+## to_match_aria_snapshot
+
+```
+def to_match_aria_snapshot(expected, timeout: nil)
+```
+
+
+Asserts that the page body matches the given [accessibility snapshot](https://playwright.dev/python/docs/aria-snapshots).
+
+**Usage**
+
+```ruby
+page.goto("https://demo.playwright.dev/todomvc/")
+expect(page).to match_aria_snapshot(<<~YAML)
+  - heading "todos"
+  - textbox "What needs to be done?"
+YAML
+```
+
+## not_to_match_aria_snapshot
+
+```
+def not_to_match_aria_snapshot(expected, timeout: nil)
+```
+
+
+The opposite of [PageAssertions#to_match_aria_snapshot](./page_assertions#to_match_aria_snapshot).
+
 ## to_have_title
 
 ```

data/documentation/docs/api/playwright.md

@@ -54,6 +54,11 @@ end
 
 This object can be used to launch or connect to Firefox, returning instances of [Browser](./browser).
 
+## request
+
+
+Exposes API that can be used for the Web API testing.
+
 ## selectors
 
 

data/documentation/docs/api/touchscreen.md

@@ -19,4 +19,4 @@ def tap_point(x, y)
 
 Dispatches a `touchstart` and `touchend` event with a single touch at the position (`x`,`y`).
 
-**NOTE**: [Page#tap_point](./page#tap_point) the method will throw if `hasTouch` option of the browser context is false.
+**NOTE**: [Touchscreen#tap_point](./touchscreen#tap_point) will throw if the `hasTouch` option of the browser context is false.

data/documentation/docs/api/tracing.md

@@ -77,6 +77,26 @@ page.goto("http://example.com")
 context.tracing.stop_chunk(path: "trace2.zip")
 ```
 
+## start_har
+
+```
+def start_har(path, content: nil, mode: nil, urlFilter: nil)
+```
+
+
+Start recording a HAR (HTTP Archive) of network activity in this context. The HAR file is written to disk when [Tracing#stop_har](./tracing#stop_har) is called, or when the returned `Disposable` is disposed.
+
+Only one HAR recording can be active at a time per [BrowserContext](./browser_context).
+
+**Usage**
+
+```ruby
+context.tracing.start_har("trace.har")
+page = context.new_page
+page.goto("https://playwright.dev")
+context.tracing.stop_har
+```
+
 ## group
 
 ```
@@ -128,3 +148,12 @@ def stop_chunk(path: nil)
 
 
 Stop the trace chunk. See [Tracing#start_chunk](./tracing#start_chunk) for more details about multiple trace chunks.
+
+## stop_har
+
+```
+def stop_har
+```
+
+
+Stop HAR recording and save the HAR file to the path given to [Tracing#start_har](./tracing#start_har).

data/documentation/docs/api/web_storage.md

@@ -0,0 +1,65 @@
+---
+sidebar_position: 10
+---
+
+# WebStorage
+
+
+WebStorage exposes the page's `localStorage` or `sessionStorage` for the current origin via an async,
+[browser-consistent](https://developer.mozilla.org/en-US/docs/Web/API/Storage) API.
+
+Instances are accessed through [Page#local_storage](./page#local_storage) and [Page#session_storage](./page#session_storage).
+
+```ruby
+page.goto("https://example.com")
+page.local_storage.set_item("token", "abc")
+token = page.local_storage.get_item("token")
+all = page.local_storage.items
+page.local_storage.remove_item("token")
+page.local_storage.clear
+```
+
+## items
+
+```
+def items
+```
+
+
+Returns all items in the storage as name/value pairs.
+
+## get_item
+
+```
+def get_item(name)
+```
+
+
+Returns the value for the given `name` if present.
+
+## set_item
+
+```
+def set_item(name, value)
+```
+
+
+Sets the value for the given `name`. Overwrites any existing value for that name.
+
+## remove_item
+
+```
+def remove_item(name)
+```
+
+
+Removes the item with the given `name`. No-op if the item is absent.
+
+## clear
+
+```
+def clear
+```
+
+
+Removes all items from the storage.